blob: 29bd378d759b258a9481dea3ef03ba0dc2d3a64d [file] [log] [blame]
Brad Bishope55ef3d2016-12-19 09:12:40 -05001/**
2 * Copyright © 2016 IBM Corporation
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Matt Spinlerf9c83c42017-08-10 08:51:45 -050016#include "config.h"
Patrick Venture043d3232018-08-31 10:10:53 -070017
18#include "mainloop.hpp"
19
Patrick Venture09791852018-04-17 17:40:00 -070020#include "env.hpp"
21#include "fan_pwm.hpp"
22#include "fan_speed.hpp"
Brad Bishope55ef3d2016-12-19 09:12:40 -050023#include "hwmon.hpp"
Patrick Venture75e56c62018-04-20 18:10:15 -070024#include "hwmonio.hpp"
Patrick Venture043d3232018-08-31 10:10:53 -070025#include "sensor.hpp"
Patrick Venture09791852018-04-17 17:40:00 -070026#include "sensorset.hpp"
Brad Bishope55ef3d2016-12-19 09:12:40 -050027#include "sysfs.hpp"
Matthew Barthbf7b7b12017-03-07 15:46:59 -060028#include "targets.hpp"
Patrick Venture09791852018-04-17 17:40:00 -070029#include "thresholds.hpp"
Brad Bishope55ef3d2016-12-19 09:12:40 -050030
William A. Kennington III0e749752018-11-06 15:25:41 -080031#include <cassert>
Patrick Venture043d3232018-08-31 10:10:53 -070032#include <cstdlib>
33#include <functional>
34#include <iostream>
35#include <memory>
36#include <phosphor-logging/elog-errors.hpp>
37#include <sstream>
38#include <string>
39#include <unordered_set>
Patrick Venture1e6324f2017-06-01 14:07:05 -070040#include <xyz/openbmc_project/Sensor/Device/error.hpp>
41
42using namespace phosphor::logging;
43
Saqib Khan973886d2017-03-15 14:01:16 -050044// Initialization for Warning Objects
45decltype(Thresholds<WarningObject>::setLo) Thresholds<WarningObject>::setLo =
46 &WarningObject::warningLow;
47decltype(Thresholds<WarningObject>::setHi) Thresholds<WarningObject>::setHi =
48 &WarningObject::warningHigh;
49decltype(Thresholds<WarningObject>::getLo) Thresholds<WarningObject>::getLo =
50 &WarningObject::warningLow;
51decltype(Thresholds<WarningObject>::getHi) Thresholds<WarningObject>::getHi =
52 &WarningObject::warningHigh;
Patrick Venture043d3232018-08-31 10:10:53 -070053decltype(
54 Thresholds<WarningObject>::alarmLo) Thresholds<WarningObject>::alarmLo =
Saqib Khan973886d2017-03-15 14:01:16 -050055 &WarningObject::warningAlarmLow;
Patrick Venture043d3232018-08-31 10:10:53 -070056decltype(
57 Thresholds<WarningObject>::alarmHi) Thresholds<WarningObject>::alarmHi =
Saqib Khan973886d2017-03-15 14:01:16 -050058 &WarningObject::warningAlarmHigh;
59
60// Initialization for Critical Objects
61decltype(Thresholds<CriticalObject>::setLo) Thresholds<CriticalObject>::setLo =
62 &CriticalObject::criticalLow;
63decltype(Thresholds<CriticalObject>::setHi) Thresholds<CriticalObject>::setHi =
64 &CriticalObject::criticalHigh;
65decltype(Thresholds<CriticalObject>::getLo) Thresholds<CriticalObject>::getLo =
66 &CriticalObject::criticalLow;
67decltype(Thresholds<CriticalObject>::getHi) Thresholds<CriticalObject>::getHi =
68 &CriticalObject::criticalHigh;
Patrick Venture043d3232018-08-31 10:10:53 -070069decltype(
70 Thresholds<CriticalObject>::alarmLo) Thresholds<CriticalObject>::alarmLo =
Saqib Khan973886d2017-03-15 14:01:16 -050071 &CriticalObject::criticalAlarmLow;
Patrick Venture043d3232018-08-31 10:10:53 -070072decltype(
73 Thresholds<CriticalObject>::alarmHi) Thresholds<CriticalObject>::alarmHi =
Saqib Khan973886d2017-03-15 14:01:16 -050074 &CriticalObject::criticalAlarmHigh;
75
Matthew Barth979c8062018-04-17 11:37:15 -050076std::string MainLoop::getID(SensorSet::container_t::const_reference sensor)
Matthew Barth31d214c2018-03-26 09:54:27 -050077{
Matthew Barth31d214c2018-03-26 09:54:27 -050078 std::string id;
79
80 /*
81 * Check if the value of the MODE_<item><X> env variable for the sensor
Matt Spinler7c424802018-05-04 10:52:40 -050082 * is set. If it is, then read the from the <item><X>_<mode>
Matthew Barth31d214c2018-03-26 09:54:27 -050083 * file. The name of the DBUS object would be the value of the env
Matt Spinler7c424802018-05-04 10:52:40 -050084 * variable LABEL_<item><mode value>. If the MODE_<item><X> env variable
Matthew Barth31d214c2018-03-26 09:54:27 -050085 * doesn't exist, then the name of DBUS object is the value of the env
86 * variable LABEL_<item><X>.
Matt Spinler7c424802018-05-04 10:52:40 -050087 *
88 * For example, if MODE_temp1 = "label", then code reads the temp1_label
89 * file. If it has a 5 in it, then it will use the following entry to
90 * name the object: LABEL_temp5 = "My DBus object name".
91 *
Matthew Barth31d214c2018-03-26 09:54:27 -050092 */
Patrick Venture7a5285d2018-04-17 19:15:05 -070093 auto mode = env::getEnv("MODE", sensor.first);
Matt Spinler7c424802018-05-04 10:52:40 -050094 if (!mode.empty())
Matthew Barth31d214c2018-03-26 09:54:27 -050095 {
Patrick Venture043d3232018-08-31 10:10:53 -070096 id = env::getIndirectID(_hwmonRoot + '/' + _instance + '/', mode,
97 sensor.first);
Matthew Barth31d214c2018-03-26 09:54:27 -050098
99 if (id.empty())
100 {
Matthew Barth979c8062018-04-17 11:37:15 -0500101 return id;
Matthew Barth31d214c2018-03-26 09:54:27 -0500102 }
103 }
104
105 // Use the ID we looked up above if there was one,
106 // otherwise use the standard one.
107 id = (id.empty()) ? sensor.first.second : id;
108
Matthew Barth979c8062018-04-17 11:37:15 -0500109 return id;
110}
111
Patrick Venture043d3232018-08-31 10:10:53 -0700112SensorIdentifiers
113 MainLoop::getIdentifiers(SensorSet::container_t::const_reference sensor)
Matthew Barth979c8062018-04-17 11:37:15 -0500114{
115 std::string id = getID(sensor);
116 std::string label;
117
118 if (!id.empty())
119 {
120 // Ignore inputs without a label.
121 label = env::getEnv("LABEL", sensor.first.first, id);
122 }
123
Patrick Venture043d3232018-08-31 10:10:53 -0700124 return std::make_tuple(std::move(id), std::move(label));
Matthew Barth979c8062018-04-17 11:37:15 -0500125}
126
127/**
128 * Reads the environment parameters of a sensor and creates an object with
129 * atleast the `Value` interface, otherwise returns without creating the object.
130 * If the `Value` interface is successfully created, by reading the sensor's
131 * corresponding sysfs file's value, the additional interfaces for the sensor
Matthew Barthd238e232018-04-17 12:01:50 -0500132 * are created and the InterfacesAdded signal is emitted. The object's state
133 * data is then returned for sensor state monitoring within the main loop.
Matthew Barth979c8062018-04-17 11:37:15 -0500134 */
William A. Kennington III4cbdfef2018-10-18 19:19:51 -0700135std::optional<ObjectStateData>
Patrick Venture043d3232018-08-31 10:10:53 -0700136 MainLoop::getObject(SensorSet::container_t::const_reference sensor)
Matthew Barth979c8062018-04-17 11:37:15 -0500137{
138 auto properties = getIdentifiers(sensor);
139 if (std::get<sensorID>(properties).empty() ||
140 std::get<sensorLabel>(properties).empty())
Matthew Barth31d214c2018-03-26 09:54:27 -0500141 {
Matthew Barthd238e232018-04-17 12:01:50 -0500142 return {};
Matthew Barth31d214c2018-03-26 09:54:27 -0500143 }
144
Patrick Venture09791852018-04-17 17:40:00 -0700145 hwmon::Attributes attrs;
146 if (!hwmon::getAttributes(sensor.first.first, attrs))
Matthew Barth31d214c2018-03-26 09:54:27 -0500147 {
Matthew Barthd238e232018-04-17 12:01:50 -0500148 return {};
Matthew Barth31d214c2018-03-26 09:54:27 -0500149 }
150
Patrick Venture043d3232018-08-31 10:10:53 -0700151 auto sensorObj =
152 std::make_unique<sensor::Sensor>(sensor.first, ioAccess, _devPath);
Matthew Barth9c431062018-05-07 13:55:29 -0500153
Matthew Barthb7985272018-04-17 10:50:36 -0500154 // Get list of return codes for removing sensors on device
155 auto devRmRCs = env::getEnv("REMOVERCS");
156 // Add sensor removal return codes defined at the device level
Matthew Barthcb3daaf2018-05-07 15:03:16 -0500157 sensorObj->addRemoveRCs(devRmRCs);
Matthew Barth31d214c2018-03-26 09:54:27 -0500158
159 std::string objectPath{_root};
160 objectPath.append(1, '/');
Patrick Venture09791852018-04-17 17:40:00 -0700161 objectPath.append(hwmon::getNamespace(attrs));
Matthew Barth31d214c2018-03-26 09:54:27 -0500162 objectPath.append(1, '/');
Matthew Barth979c8062018-04-17 11:37:15 -0500163 objectPath.append(std::get<sensorLabel>(properties));
Matthew Barth31d214c2018-03-26 09:54:27 -0500164
165 ObjectInfo info(&_bus, std::move(objectPath), Object());
Patrick Venture75e56c62018-04-20 18:10:15 -0700166 RetryIO retryIO(hwmonio::retries, hwmonio::delay);
Matthew Barthd4beecf2018-04-03 15:50:22 -0500167 if (rmSensors.find(sensor.first) != rmSensors.end())
168 {
169 // When adding a sensor that was purposely removed,
170 // don't retry on errors when reading its value
171 std::get<size_t>(retryIO) = 0;
172 }
Patrick Venture043d3232018-08-31 10:10:53 -0700173 auto valueInterface = static_cast<std::shared_ptr<ValueObject>>(nullptr);
Matthew Barth31d214c2018-03-26 09:54:27 -0500174 try
175 {
Matthew Barthca44c2e2018-04-24 15:33:25 -0500176 // Add status interface based on _fault file being present
Matthew Barth2e41b132018-05-07 14:15:45 -0500177 sensorObj->addStatus(info);
Matthew Barthcb3daaf2018-05-07 15:03:16 -0500178 valueInterface = sensorObj->addValue(retryIO, info);
Matthew Barth31d214c2018-03-26 09:54:27 -0500179 }
180 catch (const std::system_error& e)
181 {
Patrick Venture043d3232018-08-31 10:10:53 -0700182 auto file =
183 sysfs::make_sysfs_path(ioAccess.path(), sensor.first.first,
184 sensor.first.second, hwmon::entry::cinput);
Matthew Barth31d214c2018-03-26 09:54:27 -0500185#ifndef REMOVE_ON_FAIL
186 // Check sensorAdjusts for sensor removal RCs
Matthew Barthac473092018-05-07 14:41:46 -0500187 auto& sAdjusts = sensorObj->getAdjusts();
188 if (sAdjusts.rmRCs.count(e.code().value()) > 0)
Matthew Barth31d214c2018-03-26 09:54:27 -0500189 {
Matthew Barthac473092018-05-07 14:41:46 -0500190 // Return code found in sensor return code removal list
191 if (rmSensors.find(sensor.first) == rmSensors.end())
Matthew Barth31d214c2018-03-26 09:54:27 -0500192 {
Matthew Barthac473092018-05-07 14:41:46 -0500193 // Trace for sensor not already removed from dbus
194 log<level::INFO>("Sensor not added to dbus for read fail",
Patrick Venture043d3232018-08-31 10:10:53 -0700195 entry("FILE=%s", file.c_str()),
196 entry("RC=%d", e.code().value()));
197 rmSensors[std::move(sensor.first)] = std::move(sensor.second);
Matthew Barth31d214c2018-03-26 09:54:27 -0500198 }
Matthew Barthac473092018-05-07 14:41:46 -0500199 return {};
Matthew Barth31d214c2018-03-26 09:54:27 -0500200 }
201#endif
Patrick Venture043d3232018-08-31 10:10:53 -0700202 using namespace sdbusplus::xyz::openbmc_project::Sensor::Device::Error;
Matthew Barth31d214c2018-03-26 09:54:27 -0500203 report<ReadFailure>(
Patrick Venture043d3232018-08-31 10:10:53 -0700204 xyz::openbmc_project::Sensor::Device::ReadFailure::CALLOUT_ERRNO(
205 e.code().value()),
206 xyz::openbmc_project::Sensor::Device::ReadFailure::
207 CALLOUT_DEVICE_PATH(_devPath.c_str()));
Matthew Barth31d214c2018-03-26 09:54:27 -0500208
Matthew Barth31d214c2018-03-26 09:54:27 -0500209 log<level::INFO>("Logging failing sysfs file",
Patrick Venture043d3232018-08-31 10:10:53 -0700210 entry("FILE=%s", file.c_str()));
Matthew Barth31d214c2018-03-26 09:54:27 -0500211#ifdef REMOVE_ON_FAIL
Matthew Barthd238e232018-04-17 12:01:50 -0500212 return {}; /* skip adding this sensor for now. */
Matthew Barth31d214c2018-03-26 09:54:27 -0500213#else
214 exit(EXIT_FAILURE);
215#endif
216 }
217 auto sensorValue = valueInterface->value();
James Feistee73f5b2018-08-01 16:31:42 -0700218 int64_t scale = 0;
219 // scale the thresholds only if we're using doubles
220 if constexpr (std::is_same<SensorValueType, double>::value)
221 {
222 scale = sensorObj->getScale();
223 }
224 addThreshold<WarningObject>(sensor.first.first,
225 std::get<sensorID>(properties), sensorValue,
226 info, scale);
227 addThreshold<CriticalObject>(sensor.first.first,
228 std::get<sensorID>(properties), sensorValue,
229 info, scale);
Matthew Barth31d214c2018-03-26 09:54:27 -0500230
Patrick Venture043d3232018-08-31 10:10:53 -0700231 auto target =
232 addTarget<hwmon::FanSpeed>(sensor.first, ioAccess, _devPath, info);
Matthew Barth28f8e662018-03-26 16:57:36 -0500233 if (target)
Matthew Barth31d214c2018-03-26 09:54:27 -0500234 {
Matthew Barth28f8e662018-03-26 16:57:36 -0500235 target->enable();
Matthew Barth31d214c2018-03-26 09:54:27 -0500236 }
Matthew Barth28f8e662018-03-26 16:57:36 -0500237 addTarget<hwmon::FanPwm>(sensor.first, ioAccess, _devPath, info);
Matthew Barth31d214c2018-03-26 09:54:27 -0500238
239 // All the interfaces have been created. Go ahead
240 // and emit InterfacesAdded.
241 valueInterface->emit_object_added();
242
Matthew Barth9c431062018-05-07 13:55:29 -0500243 // Save sensor object specifications
244 sensorObjects[sensor.first] = std::move(sensorObj);
245
Matthew Barthd238e232018-04-17 12:01:50 -0500246 return std::make_pair(std::move(std::get<sensorLabel>(properties)),
247 std::move(info));
Matthew Barth31d214c2018-03-26 09:54:27 -0500248}
249
Patrick Venture043d3232018-08-31 10:10:53 -0700250MainLoop::MainLoop(sdbusplus::bus::bus&& bus, const std::string& param,
251 const std::string& path, const std::string& devPath,
252 const char* prefix, const char* root) :
253 _bus(std::move(bus)),
254 _manager(_bus, root), _pathParam(param), _hwmonRoot(), _instance(),
William A. Kennington III0fe4cb32018-10-18 19:19:58 -0700255 _devPath(devPath), _prefix(prefix), _root(root), state(), ioAccess(path),
William A. Kennington III0dd0c4d2018-10-18 19:20:01 -0700256 event(sdeventplus::Event::get_default()),
257 timer(event, std::bind(&MainLoop::read, this))
Brad Bishopd499ca62016-12-19 09:24:50 -0500258{
Patrick Venture73a50c72018-04-17 15:19:03 -0700259 // Strip off any trailing slashes.
Brad Bishopb8740fc2017-02-24 23:38:37 -0500260 std::string p = path;
261 while (!p.empty() && p.back() == '/')
Brad Bishop9c7b6e02016-12-19 12:43:36 -0500262 {
Brad Bishopb8740fc2017-02-24 23:38:37 -0500263 p.pop_back();
Brad Bishop9c7b6e02016-12-19 12:43:36 -0500264 }
Brad Bishopb8740fc2017-02-24 23:38:37 -0500265
Patrick Venture73a50c72018-04-17 15:19:03 -0700266 // Given the furthest right /, set instance to
267 // the basename, and hwmonRoot to the leading path.
Brad Bishopb8740fc2017-02-24 23:38:37 -0500268 auto n = p.rfind('/');
269 if (n != std::string::npos)
270 {
271 _instance.assign(p.substr(n + 1));
272 _hwmonRoot.assign(p.substr(0, n));
273 }
274
275 assert(!_instance.empty());
276 assert(!_hwmonRoot.empty());
Brad Bishopd499ca62016-12-19 09:24:50 -0500277}
278
279void MainLoop::shutdown() noexcept
280{
William A. Kennington III0fe4cb32018-10-18 19:19:58 -0700281 event.exit(0);
Brad Bishopd499ca62016-12-19 09:24:50 -0500282}
283
284void MainLoop::run()
Brad Bishope55ef3d2016-12-19 09:12:40 -0500285{
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600286 init();
287
Patrick Venture043d3232018-08-31 10:10:53 -0700288 std::function<void()> callback(std::bind(&MainLoop::read, this));
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600289 try
290 {
William A. Kennington III0dd0c4d2018-10-18 19:20:01 -0700291 timer.restart(std::chrono::microseconds(_interval));
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600292
293 // TODO: Issue#6 - Optionally look at polling interval sysfs entry.
294
295 // TODO: Issue#7 - Should probably periodically check the SensorSet
296 // for new entries.
297
William A. Kennington III0fe4cb32018-10-18 19:19:58 -0700298 _bus.attach_event(event.get(), SD_EVENT_PRIORITY_IMPORTANT);
299 event.loop();
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600300 }
William A. Kennington III0fe4cb32018-10-18 19:19:58 -0700301 catch (const std::exception& e)
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600302 {
303 log<level::ERR>("Error in sysfs polling loop",
304 entry("ERROR=%s", e.what()));
305 throw;
306 }
307}
308
309void MainLoop::init()
310{
Brad Bishope55ef3d2016-12-19 09:12:40 -0500311 // Check sysfs for available sensors.
Brad Bishop4db64422017-02-16 11:33:32 -0500312 auto sensors = std::make_unique<SensorSet>(_hwmonRoot + '/' + _instance);
Brad Bishope55ef3d2016-12-19 09:12:40 -0500313
Patrick Venturedb7ecb62018-10-23 19:42:23 -0700314 for (const auto& i : *sensors)
Brad Bishop75b4ab82017-01-06 09:33:50 -0500315 {
Matthew Barthd238e232018-04-17 12:01:50 -0500316 auto object = getObject(i);
317 if (object)
318 {
319 // Construct the SensorSet value
320 // std::tuple<SensorSet::mapped_type,
321 // std::string(Sensor Label),
322 // ObjectInfo>
Patrick Venture043d3232018-08-31 10:10:53 -0700323 auto value =
324 std::make_tuple(std::move(i.second), std::move((*object).first),
325 std::move((*object).second));
Matthew Barthd238e232018-04-17 12:01:50 -0500326
327 state[std::move(i.first)] = std::move(value);
328 }
Brad Bishop75b4ab82017-01-06 09:33:50 -0500329 }
330
Patrick Venture62503a42017-05-23 07:30:29 -0700331 /* If there are no sensors specified by labels, exit. */
332 if (0 == state.size())
333 {
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600334 exit(0);
Patrick Venture62503a42017-05-23 07:30:29 -0700335 }
336
Brad Bishop9c7b6e02016-12-19 12:43:36 -0500337 {
Patrick Venturec897d8b2018-04-23 19:01:56 -0700338 std::stringstream ss;
Patrick Venture043d3232018-08-31 10:10:53 -0700339 ss << _prefix << "-"
Patrick Venturec897d8b2018-04-23 19:01:56 -0700340 << std::to_string(std::hash<std::string>{}(_devPath + _pathParam))
341 << ".Hwmon1";
342
343 _bus.request_name(ss.str().c_str());
Brad Bishop9c7b6e02016-12-19 12:43:36 -0500344 }
345
Patrick Ventureab10f162017-05-22 09:44:50 -0700346 {
Patrick Venturea24c8802018-04-17 19:38:06 -0700347 auto interval = env::getEnv("INTERVAL");
348 if (!interval.empty())
Patrick Ventureab10f162017-05-22 09:44:50 -0700349 {
Patrick Venture50cf1c52018-04-18 09:21:41 -0700350 _interval = std::strtoull(interval.c_str(), NULL, 10);
Patrick Ventureab10f162017-05-22 09:44:50 -0700351 }
352 }
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600353}
Patrick Ventureab10f162017-05-22 09:44:50 -0700354
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600355void MainLoop::read()
356{
Brad Bishope55ef3d2016-12-19 09:12:40 -0500357 // TODO: Issue#3 - Need to make calls to the dbus sensor cache here to
358 // ensure the objects all exist?
359
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600360 // Iterate through all the sensors.
361 for (auto& i : state)
362 {
363 auto& attrs = std::get<0>(i.second);
364 if (attrs.find(hwmon::entry::input) != attrs.end())
Brad Bishope55ef3d2016-12-19 09:12:40 -0500365 {
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600366 // Read value from sensor.
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600367 std::string input = hwmon::entry::cinput;
Patrick Venture043d3232018-08-31 10:10:53 -0700368 if (i.first.first == "pwm")
369 {
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600370 input = "";
371 }
372
373 try
Brad Bishope55ef3d2016-12-19 09:12:40 -0500374 {
Patrick Venture685efa12018-10-12 18:00:13 -0700375 int64_t value;
Matthew Barth27c4a392018-04-25 14:38:51 -0500376 auto& objInfo = std::get<ObjectInfo>(i.second);
377 auto& obj = std::get<Object>(objInfo);
378
379 auto it = obj.find(InterfaceType::STATUS);
380 if (it != obj.end())
381 {
Matthew Barthbfcaf3d2018-04-25 15:05:58 -0500382 auto fault = ioAccess.read(
Patrick Venture043d3232018-08-31 10:10:53 -0700383 i.first.first, i.first.second, hwmon::entry::fault,
384 hwmonio::retries, hwmonio::delay);
William A. Kennington III4cbdfef2018-10-18 19:19:51 -0700385 auto statusIface =
386 std::any_cast<std::shared_ptr<StatusObject>>(
387 it->second);
Matthew Barthbfcaf3d2018-04-25 15:05:58 -0500388 if (!statusIface->functional((fault == 0) ? true : false))
Matthew Barth27c4a392018-04-25 14:38:51 -0500389 {
390 continue;
391 }
392 }
393
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600394 // Retry for up to a second if device is busy
395 // or has a transient error.
Patrick Ventureb28f4322018-09-14 10:19:14 -0700396 std::unique_ptr<sensor::Sensor>& sensor =
397 sensorObjects[i.first];
398
399 sensor->unlockGpio();
Patrick Venture9331ab72018-01-29 09:48:47 -0800400
Patrick Venture043d3232018-08-31 10:10:53 -0700401 value = ioAccess.read(i.first.first, i.first.second, input,
402 hwmonio::retries, hwmonio::delay);
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600403
Patrick Ventureb28f4322018-09-14 10:19:14 -0700404 sensor->lockGpio();
405
406 value = sensor->adjustValue(value);
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600407
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600408 for (auto& iface : obj)
Brad Bishopdddb7152017-01-06 09:54:23 -0500409 {
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600410 auto valueIface = std::shared_ptr<ValueObject>();
411 auto warnIface = std::shared_ptr<WarningObject>();
412 auto critIface = std::shared_ptr<CriticalObject>();
Brad Bishop754d38c2017-09-08 00:46:58 -0400413
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600414 switch (iface.first)
Brad Bishope0b7d052017-01-06 15:30:23 -0500415 {
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600416 case InterfaceType::VALUE:
William A. Kennington III4cbdfef2018-10-18 19:19:51 -0700417 valueIface =
418 std::any_cast<std::shared_ptr<ValueObject>>(
419 iface.second);
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600420 valueIface->value(value);
421 break;
422 case InterfaceType::WARN:
423 checkThresholds<WarningObject>(iface.second, value);
424 break;
425 case InterfaceType::CRIT:
Patrick Venture043d3232018-08-31 10:10:53 -0700426 checkThresholds<CriticalObject>(iface.second,
427 value);
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600428 break;
429 default:
430 break;
Brad Bishope0b7d052017-01-06 15:30:23 -0500431 }
Brad Bishopdddb7152017-01-06 09:54:23 -0500432 }
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600433 }
434 catch (const std::system_error& e)
435 {
Matthew Barth38c74e72018-04-02 12:41:26 -0500436 auto file = sysfs::make_sysfs_path(
Patrick Venture043d3232018-08-31 10:10:53 -0700437 ioAccess.path(), i.first.first, i.first.second,
438 hwmon::entry::cinput);
Matthew Barth8772ce32018-03-22 16:03:06 -0500439#ifndef REMOVE_ON_FAIL
440 // Check sensorAdjusts for sensor removal RCs
Matthew Barthac473092018-05-07 14:41:46 -0500441 auto& sAdjusts = sensorObjects[i.first]->getAdjusts();
442 if (sAdjusts.rmRCs.count(e.code().value()) > 0)
Matthew Barth8772ce32018-03-22 16:03:06 -0500443 {
Matthew Barthac473092018-05-07 14:41:46 -0500444 // Return code found in sensor return code removal list
445 if (rmSensors.find(i.first) == rmSensors.end())
Matthew Barth8772ce32018-03-22 16:03:06 -0500446 {
Matthew Barthac473092018-05-07 14:41:46 -0500447 // Trace for sensor not already removed from dbus
448 log<level::INFO>(
Patrick Venture043d3232018-08-31 10:10:53 -0700449 "Remove sensor from dbus for read fail",
450 entry("FILE=%s", file.c_str()),
451 entry("RC=%d", e.code().value()));
Matthew Barthac473092018-05-07 14:41:46 -0500452 // Mark this sensor to be removed from dbus
453 rmSensors[i.first] = std::get<0>(i.second);
Matthew Barth8772ce32018-03-22 16:03:06 -0500454 }
Matthew Barthac473092018-05-07 14:41:46 -0500455 continue;
Matthew Barth8772ce32018-03-22 16:03:06 -0500456 }
457#endif
Patrick Venture043d3232018-08-31 10:10:53 -0700458 using namespace sdbusplus::xyz::openbmc_project::Sensor::
459 Device::Error;
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600460 report<ReadFailure>(
Patrick Venture043d3232018-08-31 10:10:53 -0700461 xyz::openbmc_project::Sensor::Device::ReadFailure::
462 CALLOUT_ERRNO(e.code().value()),
463 xyz::openbmc_project::Sensor::Device::ReadFailure::
464 CALLOUT_DEVICE_PATH(_devPath.c_str()));
Matt Spinler9b65f762017-10-05 10:36:22 -0500465
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600466 log<level::INFO>("Logging failing sysfs file",
Patrick Venture043d3232018-08-31 10:10:53 -0700467 entry("FILE=%s", file.c_str()));
Matt Spinler9b65f762017-10-05 10:36:22 -0500468
Matt Spinlerf9c83c42017-08-10 08:51:45 -0500469#ifdef REMOVE_ON_FAIL
Matthew Barth33db92b2018-03-26 09:55:19 -0500470 rmSensors[i.first] = std::get<0>(i.second);
Matt Spinlerf9c83c42017-08-10 08:51:45 -0500471#else
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600472 exit(EXIT_FAILURE);
Matt Spinlerf9c83c42017-08-10 08:51:45 -0500473#endif
Brad Bishope55ef3d2016-12-19 09:12:40 -0500474 }
475 }
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600476 }
Brad Bishope55ef3d2016-12-19 09:12:40 -0500477
Matthew Barth8772ce32018-03-22 16:03:06 -0500478 // Remove any sensors marked for removal
Patrick Venturedb7ecb62018-10-23 19:42:23 -0700479 for (const auto& i : rmSensors)
Deepak Kodihalli2a51a9c2018-03-07 02:39:40 -0600480 {
Matthew Barth33db92b2018-03-26 09:55:19 -0500481 state.erase(i.first);
Brad Bishope55ef3d2016-12-19 09:12:40 -0500482 }
Matthew Barth31d214c2018-03-26 09:54:27 -0500483
484#ifndef REMOVE_ON_FAIL
485 // Attempt to add any sensors that were removed
486 auto it = rmSensors.begin();
487 while (it != rmSensors.end())
488 {
489 if (state.find(it->first) == state.end())
490 {
491 SensorSet::container_t::value_type ssValueType =
Patrick Venture043d3232018-08-31 10:10:53 -0700492 std::make_pair(it->first, it->second);
Matthew Barthd238e232018-04-17 12:01:50 -0500493 auto object = getObject(ssValueType);
494 if (object)
Matthew Barth31d214c2018-03-26 09:54:27 -0500495 {
Matthew Barthd238e232018-04-17 12:01:50 -0500496 // Construct the SensorSet value
497 // std::tuple<SensorSet::mapped_type,
498 // std::string(Sensor Label),
499 // ObjectInfo>
500 auto value = std::make_tuple(std::move(ssValueType.second),
501 std::move((*object).first),
502 std::move((*object).second));
503
504 state[std::move(ssValueType.first)] = std::move(value);
505
Matthew Barth31d214c2018-03-26 09:54:27 -0500506 // Sensor object added, erase entry from removal list
Matthew Barth38c74e72018-04-02 12:41:26 -0500507 auto file = sysfs::make_sysfs_path(
Patrick Venture043d3232018-08-31 10:10:53 -0700508 ioAccess.path(), it->first.first, it->first.second,
509 hwmon::entry::cinput);
510 log<level::INFO>("Added sensor to dbus after successful read",
511 entry("FILE=%s", file.c_str()));
Matthew Barth31d214c2018-03-26 09:54:27 -0500512 it = rmSensors.erase(it);
513 }
514 else
515 {
516 ++it;
517 }
518 }
519 else
520 {
521 // Sanity check to remove sensors that were re-added
522 it = rmSensors.erase(it);
523 }
524 }
525#endif
Brad Bishope55ef3d2016-12-19 09:12:40 -0500526}
527
528// vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4