Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 1 | /** |
| 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 Spinler | f9c83c4 | 2017-08-10 08:51:45 -0500 | [diff] [blame] | 16 | #include "config.h" |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 17 | |
| 18 | #include "mainloop.hpp" |
| 19 | |
Patrick Venture | 0979185 | 2018-04-17 17:40:00 -0700 | [diff] [blame] | 20 | #include "env.hpp" |
| 21 | #include "fan_pwm.hpp" |
| 22 | #include "fan_speed.hpp" |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 23 | #include "hwmon.hpp" |
Patrick Venture | 75e56c6 | 2018-04-20 18:10:15 -0700 | [diff] [blame] | 24 | #include "hwmonio.hpp" |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 25 | #include "sensor.hpp" |
Patrick Venture | 0979185 | 2018-04-17 17:40:00 -0700 | [diff] [blame] | 26 | #include "sensorset.hpp" |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 27 | #include "sysfs.hpp" |
Matthew Barth | bf7b7b1 | 2017-03-07 15:46:59 -0600 | [diff] [blame] | 28 | #include "targets.hpp" |
Patrick Venture | 0979185 | 2018-04-17 17:40:00 -0700 | [diff] [blame] | 29 | #include "thresholds.hpp" |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 30 | |
William A. Kennington III | 0e74975 | 2018-11-06 15:25:41 -0800 | [diff] [blame^] | 31 | #include <cassert> |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 32 | #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 Venture | 1e6324f | 2017-06-01 14:07:05 -0700 | [diff] [blame] | 40 | #include <xyz/openbmc_project/Sensor/Device/error.hpp> |
| 41 | |
| 42 | using namespace phosphor::logging; |
| 43 | |
Saqib Khan | 973886d | 2017-03-15 14:01:16 -0500 | [diff] [blame] | 44 | // Initialization for Warning Objects |
| 45 | decltype(Thresholds<WarningObject>::setLo) Thresholds<WarningObject>::setLo = |
| 46 | &WarningObject::warningLow; |
| 47 | decltype(Thresholds<WarningObject>::setHi) Thresholds<WarningObject>::setHi = |
| 48 | &WarningObject::warningHigh; |
| 49 | decltype(Thresholds<WarningObject>::getLo) Thresholds<WarningObject>::getLo = |
| 50 | &WarningObject::warningLow; |
| 51 | decltype(Thresholds<WarningObject>::getHi) Thresholds<WarningObject>::getHi = |
| 52 | &WarningObject::warningHigh; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 53 | decltype( |
| 54 | Thresholds<WarningObject>::alarmLo) Thresholds<WarningObject>::alarmLo = |
Saqib Khan | 973886d | 2017-03-15 14:01:16 -0500 | [diff] [blame] | 55 | &WarningObject::warningAlarmLow; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 56 | decltype( |
| 57 | Thresholds<WarningObject>::alarmHi) Thresholds<WarningObject>::alarmHi = |
Saqib Khan | 973886d | 2017-03-15 14:01:16 -0500 | [diff] [blame] | 58 | &WarningObject::warningAlarmHigh; |
| 59 | |
| 60 | // Initialization for Critical Objects |
| 61 | decltype(Thresholds<CriticalObject>::setLo) Thresholds<CriticalObject>::setLo = |
| 62 | &CriticalObject::criticalLow; |
| 63 | decltype(Thresholds<CriticalObject>::setHi) Thresholds<CriticalObject>::setHi = |
| 64 | &CriticalObject::criticalHigh; |
| 65 | decltype(Thresholds<CriticalObject>::getLo) Thresholds<CriticalObject>::getLo = |
| 66 | &CriticalObject::criticalLow; |
| 67 | decltype(Thresholds<CriticalObject>::getHi) Thresholds<CriticalObject>::getHi = |
| 68 | &CriticalObject::criticalHigh; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 69 | decltype( |
| 70 | Thresholds<CriticalObject>::alarmLo) Thresholds<CriticalObject>::alarmLo = |
Saqib Khan | 973886d | 2017-03-15 14:01:16 -0500 | [diff] [blame] | 71 | &CriticalObject::criticalAlarmLow; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 72 | decltype( |
| 73 | Thresholds<CriticalObject>::alarmHi) Thresholds<CriticalObject>::alarmHi = |
Saqib Khan | 973886d | 2017-03-15 14:01:16 -0500 | [diff] [blame] | 74 | &CriticalObject::criticalAlarmHigh; |
| 75 | |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 76 | std::string MainLoop::getID(SensorSet::container_t::const_reference sensor) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 77 | { |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 78 | std::string id; |
| 79 | |
| 80 | /* |
| 81 | * Check if the value of the MODE_<item><X> env variable for the sensor |
Matt Spinler | 7c42480 | 2018-05-04 10:52:40 -0500 | [diff] [blame] | 82 | * is set. If it is, then read the from the <item><X>_<mode> |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 83 | * file. The name of the DBUS object would be the value of the env |
Matt Spinler | 7c42480 | 2018-05-04 10:52:40 -0500 | [diff] [blame] | 84 | * variable LABEL_<item><mode value>. If the MODE_<item><X> env variable |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 85 | * doesn't exist, then the name of DBUS object is the value of the env |
| 86 | * variable LABEL_<item><X>. |
Matt Spinler | 7c42480 | 2018-05-04 10:52:40 -0500 | [diff] [blame] | 87 | * |
| 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 Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 92 | */ |
Patrick Venture | 7a5285d | 2018-04-17 19:15:05 -0700 | [diff] [blame] | 93 | auto mode = env::getEnv("MODE", sensor.first); |
Matt Spinler | 7c42480 | 2018-05-04 10:52:40 -0500 | [diff] [blame] | 94 | if (!mode.empty()) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 95 | { |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 96 | id = env::getIndirectID(_hwmonRoot + '/' + _instance + '/', mode, |
| 97 | sensor.first); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 98 | |
| 99 | if (id.empty()) |
| 100 | { |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 101 | return id; |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 102 | } |
| 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 Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 109 | return id; |
| 110 | } |
| 111 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 112 | SensorIdentifiers |
| 113 | MainLoop::getIdentifiers(SensorSet::container_t::const_reference sensor) |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 114 | { |
| 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 Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 124 | return std::make_tuple(std::move(id), std::move(label)); |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 125 | } |
| 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 Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 132 | * 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 Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 134 | */ |
William A. Kennington III | 4cbdfef | 2018-10-18 19:19:51 -0700 | [diff] [blame] | 135 | std::optional<ObjectStateData> |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 136 | MainLoop::getObject(SensorSet::container_t::const_reference sensor) |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 137 | { |
| 138 | auto properties = getIdentifiers(sensor); |
| 139 | if (std::get<sensorID>(properties).empty() || |
| 140 | std::get<sensorLabel>(properties).empty()) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 141 | { |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 142 | return {}; |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 143 | } |
| 144 | |
Patrick Venture | 0979185 | 2018-04-17 17:40:00 -0700 | [diff] [blame] | 145 | hwmon::Attributes attrs; |
| 146 | if (!hwmon::getAttributes(sensor.first.first, attrs)) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 147 | { |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 148 | return {}; |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 149 | } |
| 150 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 151 | auto sensorObj = |
| 152 | std::make_unique<sensor::Sensor>(sensor.first, ioAccess, _devPath); |
Matthew Barth | 9c43106 | 2018-05-07 13:55:29 -0500 | [diff] [blame] | 153 | |
Matthew Barth | b798527 | 2018-04-17 10:50:36 -0500 | [diff] [blame] | 154 | // 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 Barth | cb3daaf | 2018-05-07 15:03:16 -0500 | [diff] [blame] | 157 | sensorObj->addRemoveRCs(devRmRCs); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 158 | |
| 159 | std::string objectPath{_root}; |
| 160 | objectPath.append(1, '/'); |
Patrick Venture | 0979185 | 2018-04-17 17:40:00 -0700 | [diff] [blame] | 161 | objectPath.append(hwmon::getNamespace(attrs)); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 162 | objectPath.append(1, '/'); |
Matthew Barth | 979c806 | 2018-04-17 11:37:15 -0500 | [diff] [blame] | 163 | objectPath.append(std::get<sensorLabel>(properties)); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 164 | |
| 165 | ObjectInfo info(&_bus, std::move(objectPath), Object()); |
Patrick Venture | 75e56c6 | 2018-04-20 18:10:15 -0700 | [diff] [blame] | 166 | RetryIO retryIO(hwmonio::retries, hwmonio::delay); |
Matthew Barth | d4beecf | 2018-04-03 15:50:22 -0500 | [diff] [blame] | 167 | 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 Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 173 | auto valueInterface = static_cast<std::shared_ptr<ValueObject>>(nullptr); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 174 | try |
| 175 | { |
Matthew Barth | ca44c2e | 2018-04-24 15:33:25 -0500 | [diff] [blame] | 176 | // Add status interface based on _fault file being present |
Matthew Barth | 2e41b13 | 2018-05-07 14:15:45 -0500 | [diff] [blame] | 177 | sensorObj->addStatus(info); |
Matthew Barth | cb3daaf | 2018-05-07 15:03:16 -0500 | [diff] [blame] | 178 | valueInterface = sensorObj->addValue(retryIO, info); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 179 | } |
| 180 | catch (const std::system_error& e) |
| 181 | { |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 182 | auto file = |
| 183 | sysfs::make_sysfs_path(ioAccess.path(), sensor.first.first, |
| 184 | sensor.first.second, hwmon::entry::cinput); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 185 | #ifndef REMOVE_ON_FAIL |
| 186 | // Check sensorAdjusts for sensor removal RCs |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 187 | auto& sAdjusts = sensorObj->getAdjusts(); |
| 188 | if (sAdjusts.rmRCs.count(e.code().value()) > 0) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 189 | { |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 190 | // Return code found in sensor return code removal list |
| 191 | if (rmSensors.find(sensor.first) == rmSensors.end()) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 192 | { |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 193 | // Trace for sensor not already removed from dbus |
| 194 | log<level::INFO>("Sensor not added to dbus for read fail", |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 195 | entry("FILE=%s", file.c_str()), |
| 196 | entry("RC=%d", e.code().value())); |
| 197 | rmSensors[std::move(sensor.first)] = std::move(sensor.second); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 198 | } |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 199 | return {}; |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 200 | } |
| 201 | #endif |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 202 | using namespace sdbusplus::xyz::openbmc_project::Sensor::Device::Error; |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 203 | report<ReadFailure>( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 204 | 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 Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 208 | |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 209 | log<level::INFO>("Logging failing sysfs file", |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 210 | entry("FILE=%s", file.c_str())); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 211 | #ifdef REMOVE_ON_FAIL |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 212 | return {}; /* skip adding this sensor for now. */ |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 213 | #else |
| 214 | exit(EXIT_FAILURE); |
| 215 | #endif |
| 216 | } |
| 217 | auto sensorValue = valueInterface->value(); |
James Feist | ee73f5b | 2018-08-01 16:31:42 -0700 | [diff] [blame] | 218 | 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 Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 230 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 231 | auto target = |
| 232 | addTarget<hwmon::FanSpeed>(sensor.first, ioAccess, _devPath, info); |
Matthew Barth | 28f8e66 | 2018-03-26 16:57:36 -0500 | [diff] [blame] | 233 | if (target) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 234 | { |
Matthew Barth | 28f8e66 | 2018-03-26 16:57:36 -0500 | [diff] [blame] | 235 | target->enable(); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 236 | } |
Matthew Barth | 28f8e66 | 2018-03-26 16:57:36 -0500 | [diff] [blame] | 237 | addTarget<hwmon::FanPwm>(sensor.first, ioAccess, _devPath, info); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 238 | |
| 239 | // All the interfaces have been created. Go ahead |
| 240 | // and emit InterfacesAdded. |
| 241 | valueInterface->emit_object_added(); |
| 242 | |
Matthew Barth | 9c43106 | 2018-05-07 13:55:29 -0500 | [diff] [blame] | 243 | // Save sensor object specifications |
| 244 | sensorObjects[sensor.first] = std::move(sensorObj); |
| 245 | |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 246 | return std::make_pair(std::move(std::get<sensorLabel>(properties)), |
| 247 | std::move(info)); |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 248 | } |
| 249 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 250 | MainLoop::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 III | 0fe4cb3 | 2018-10-18 19:19:58 -0700 | [diff] [blame] | 255 | _devPath(devPath), _prefix(prefix), _root(root), state(), ioAccess(path), |
William A. Kennington III | 0dd0c4d | 2018-10-18 19:20:01 -0700 | [diff] [blame] | 256 | event(sdeventplus::Event::get_default()), |
| 257 | timer(event, std::bind(&MainLoop::read, this)) |
Brad Bishop | d499ca6 | 2016-12-19 09:24:50 -0500 | [diff] [blame] | 258 | { |
Patrick Venture | 73a50c7 | 2018-04-17 15:19:03 -0700 | [diff] [blame] | 259 | // Strip off any trailing slashes. |
Brad Bishop | b8740fc | 2017-02-24 23:38:37 -0500 | [diff] [blame] | 260 | std::string p = path; |
| 261 | while (!p.empty() && p.back() == '/') |
Brad Bishop | 9c7b6e0 | 2016-12-19 12:43:36 -0500 | [diff] [blame] | 262 | { |
Brad Bishop | b8740fc | 2017-02-24 23:38:37 -0500 | [diff] [blame] | 263 | p.pop_back(); |
Brad Bishop | 9c7b6e0 | 2016-12-19 12:43:36 -0500 | [diff] [blame] | 264 | } |
Brad Bishop | b8740fc | 2017-02-24 23:38:37 -0500 | [diff] [blame] | 265 | |
Patrick Venture | 73a50c7 | 2018-04-17 15:19:03 -0700 | [diff] [blame] | 266 | // Given the furthest right /, set instance to |
| 267 | // the basename, and hwmonRoot to the leading path. |
Brad Bishop | b8740fc | 2017-02-24 23:38:37 -0500 | [diff] [blame] | 268 | 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 Bishop | d499ca6 | 2016-12-19 09:24:50 -0500 | [diff] [blame] | 277 | } |
| 278 | |
| 279 | void MainLoop::shutdown() noexcept |
| 280 | { |
William A. Kennington III | 0fe4cb3 | 2018-10-18 19:19:58 -0700 | [diff] [blame] | 281 | event.exit(0); |
Brad Bishop | d499ca6 | 2016-12-19 09:24:50 -0500 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | void MainLoop::run() |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 285 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 286 | init(); |
| 287 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 288 | std::function<void()> callback(std::bind(&MainLoop::read, this)); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 289 | try |
| 290 | { |
William A. Kennington III | 0dd0c4d | 2018-10-18 19:20:01 -0700 | [diff] [blame] | 291 | timer.restart(std::chrono::microseconds(_interval)); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 292 | |
| 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 III | 0fe4cb3 | 2018-10-18 19:19:58 -0700 | [diff] [blame] | 298 | _bus.attach_event(event.get(), SD_EVENT_PRIORITY_IMPORTANT); |
| 299 | event.loop(); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 300 | } |
William A. Kennington III | 0fe4cb3 | 2018-10-18 19:19:58 -0700 | [diff] [blame] | 301 | catch (const std::exception& e) |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 302 | { |
| 303 | log<level::ERR>("Error in sysfs polling loop", |
| 304 | entry("ERROR=%s", e.what())); |
| 305 | throw; |
| 306 | } |
| 307 | } |
| 308 | |
| 309 | void MainLoop::init() |
| 310 | { |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 311 | // Check sysfs for available sensors. |
Brad Bishop | 4db6442 | 2017-02-16 11:33:32 -0500 | [diff] [blame] | 312 | auto sensors = std::make_unique<SensorSet>(_hwmonRoot + '/' + _instance); |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 313 | |
Patrick Venture | db7ecb6 | 2018-10-23 19:42:23 -0700 | [diff] [blame] | 314 | for (const auto& i : *sensors) |
Brad Bishop | 75b4ab8 | 2017-01-06 09:33:50 -0500 | [diff] [blame] | 315 | { |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 316 | 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 Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 323 | auto value = |
| 324 | std::make_tuple(std::move(i.second), std::move((*object).first), |
| 325 | std::move((*object).second)); |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 326 | |
| 327 | state[std::move(i.first)] = std::move(value); |
| 328 | } |
Brad Bishop | 75b4ab8 | 2017-01-06 09:33:50 -0500 | [diff] [blame] | 329 | } |
| 330 | |
Patrick Venture | 62503a4 | 2017-05-23 07:30:29 -0700 | [diff] [blame] | 331 | /* If there are no sensors specified by labels, exit. */ |
| 332 | if (0 == state.size()) |
| 333 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 334 | exit(0); |
Patrick Venture | 62503a4 | 2017-05-23 07:30:29 -0700 | [diff] [blame] | 335 | } |
| 336 | |
Brad Bishop | 9c7b6e0 | 2016-12-19 12:43:36 -0500 | [diff] [blame] | 337 | { |
Patrick Venture | c897d8b | 2018-04-23 19:01:56 -0700 | [diff] [blame] | 338 | std::stringstream ss; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 339 | ss << _prefix << "-" |
Patrick Venture | c897d8b | 2018-04-23 19:01:56 -0700 | [diff] [blame] | 340 | << std::to_string(std::hash<std::string>{}(_devPath + _pathParam)) |
| 341 | << ".Hwmon1"; |
| 342 | |
| 343 | _bus.request_name(ss.str().c_str()); |
Brad Bishop | 9c7b6e0 | 2016-12-19 12:43:36 -0500 | [diff] [blame] | 344 | } |
| 345 | |
Patrick Venture | ab10f16 | 2017-05-22 09:44:50 -0700 | [diff] [blame] | 346 | { |
Patrick Venture | a24c880 | 2018-04-17 19:38:06 -0700 | [diff] [blame] | 347 | auto interval = env::getEnv("INTERVAL"); |
| 348 | if (!interval.empty()) |
Patrick Venture | ab10f16 | 2017-05-22 09:44:50 -0700 | [diff] [blame] | 349 | { |
Patrick Venture | 50cf1c5 | 2018-04-18 09:21:41 -0700 | [diff] [blame] | 350 | _interval = std::strtoull(interval.c_str(), NULL, 10); |
Patrick Venture | ab10f16 | 2017-05-22 09:44:50 -0700 | [diff] [blame] | 351 | } |
| 352 | } |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 353 | } |
Patrick Venture | ab10f16 | 2017-05-22 09:44:50 -0700 | [diff] [blame] | 354 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 355 | void MainLoop::read() |
| 356 | { |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 357 | // TODO: Issue#3 - Need to make calls to the dbus sensor cache here to |
| 358 | // ensure the objects all exist? |
| 359 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 360 | // 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 Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 365 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 366 | // Read value from sensor. |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 367 | std::string input = hwmon::entry::cinput; |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 368 | if (i.first.first == "pwm") |
| 369 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 370 | input = ""; |
| 371 | } |
| 372 | |
| 373 | try |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 374 | { |
Patrick Venture | 685efa1 | 2018-10-12 18:00:13 -0700 | [diff] [blame] | 375 | int64_t value; |
Matthew Barth | 27c4a39 | 2018-04-25 14:38:51 -0500 | [diff] [blame] | 376 | 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 Barth | bfcaf3d | 2018-04-25 15:05:58 -0500 | [diff] [blame] | 382 | auto fault = ioAccess.read( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 383 | i.first.first, i.first.second, hwmon::entry::fault, |
| 384 | hwmonio::retries, hwmonio::delay); |
William A. Kennington III | 4cbdfef | 2018-10-18 19:19:51 -0700 | [diff] [blame] | 385 | auto statusIface = |
| 386 | std::any_cast<std::shared_ptr<StatusObject>>( |
| 387 | it->second); |
Matthew Barth | bfcaf3d | 2018-04-25 15:05:58 -0500 | [diff] [blame] | 388 | if (!statusIface->functional((fault == 0) ? true : false)) |
Matthew Barth | 27c4a39 | 2018-04-25 14:38:51 -0500 | [diff] [blame] | 389 | { |
| 390 | continue; |
| 391 | } |
| 392 | } |
| 393 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 394 | // Retry for up to a second if device is busy |
| 395 | // or has a transient error. |
Patrick Venture | b28f432 | 2018-09-14 10:19:14 -0700 | [diff] [blame] | 396 | std::unique_ptr<sensor::Sensor>& sensor = |
| 397 | sensorObjects[i.first]; |
| 398 | |
| 399 | sensor->unlockGpio(); |
Patrick Venture | 9331ab7 | 2018-01-29 09:48:47 -0800 | [diff] [blame] | 400 | |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 401 | value = ioAccess.read(i.first.first, i.first.second, input, |
| 402 | hwmonio::retries, hwmonio::delay); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 403 | |
Patrick Venture | b28f432 | 2018-09-14 10:19:14 -0700 | [diff] [blame] | 404 | sensor->lockGpio(); |
| 405 | |
| 406 | value = sensor->adjustValue(value); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 407 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 408 | for (auto& iface : obj) |
Brad Bishop | dddb715 | 2017-01-06 09:54:23 -0500 | [diff] [blame] | 409 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 410 | auto valueIface = std::shared_ptr<ValueObject>(); |
| 411 | auto warnIface = std::shared_ptr<WarningObject>(); |
| 412 | auto critIface = std::shared_ptr<CriticalObject>(); |
Brad Bishop | 754d38c | 2017-09-08 00:46:58 -0400 | [diff] [blame] | 413 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 414 | switch (iface.first) |
Brad Bishop | e0b7d05 | 2017-01-06 15:30:23 -0500 | [diff] [blame] | 415 | { |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 416 | case InterfaceType::VALUE: |
William A. Kennington III | 4cbdfef | 2018-10-18 19:19:51 -0700 | [diff] [blame] | 417 | valueIface = |
| 418 | std::any_cast<std::shared_ptr<ValueObject>>( |
| 419 | iface.second); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 420 | valueIface->value(value); |
| 421 | break; |
| 422 | case InterfaceType::WARN: |
| 423 | checkThresholds<WarningObject>(iface.second, value); |
| 424 | break; |
| 425 | case InterfaceType::CRIT: |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 426 | checkThresholds<CriticalObject>(iface.second, |
| 427 | value); |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 428 | break; |
| 429 | default: |
| 430 | break; |
Brad Bishop | e0b7d05 | 2017-01-06 15:30:23 -0500 | [diff] [blame] | 431 | } |
Brad Bishop | dddb715 | 2017-01-06 09:54:23 -0500 | [diff] [blame] | 432 | } |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 433 | } |
| 434 | catch (const std::system_error& e) |
| 435 | { |
Matthew Barth | 38c74e7 | 2018-04-02 12:41:26 -0500 | [diff] [blame] | 436 | auto file = sysfs::make_sysfs_path( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 437 | ioAccess.path(), i.first.first, i.first.second, |
| 438 | hwmon::entry::cinput); |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 439 | #ifndef REMOVE_ON_FAIL |
| 440 | // Check sensorAdjusts for sensor removal RCs |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 441 | auto& sAdjusts = sensorObjects[i.first]->getAdjusts(); |
| 442 | if (sAdjusts.rmRCs.count(e.code().value()) > 0) |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 443 | { |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 444 | // Return code found in sensor return code removal list |
| 445 | if (rmSensors.find(i.first) == rmSensors.end()) |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 446 | { |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 447 | // Trace for sensor not already removed from dbus |
| 448 | log<level::INFO>( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 449 | "Remove sensor from dbus for read fail", |
| 450 | entry("FILE=%s", file.c_str()), |
| 451 | entry("RC=%d", e.code().value())); |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 452 | // Mark this sensor to be removed from dbus |
| 453 | rmSensors[i.first] = std::get<0>(i.second); |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 454 | } |
Matthew Barth | ac47309 | 2018-05-07 14:41:46 -0500 | [diff] [blame] | 455 | continue; |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 456 | } |
| 457 | #endif |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 458 | using namespace sdbusplus::xyz::openbmc_project::Sensor:: |
| 459 | Device::Error; |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 460 | report<ReadFailure>( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 461 | 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 Spinler | 9b65f76 | 2017-10-05 10:36:22 -0500 | [diff] [blame] | 465 | |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 466 | log<level::INFO>("Logging failing sysfs file", |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 467 | entry("FILE=%s", file.c_str())); |
Matt Spinler | 9b65f76 | 2017-10-05 10:36:22 -0500 | [diff] [blame] | 468 | |
Matt Spinler | f9c83c4 | 2017-08-10 08:51:45 -0500 | [diff] [blame] | 469 | #ifdef REMOVE_ON_FAIL |
Matthew Barth | 33db92b | 2018-03-26 09:55:19 -0500 | [diff] [blame] | 470 | rmSensors[i.first] = std::get<0>(i.second); |
Matt Spinler | f9c83c4 | 2017-08-10 08:51:45 -0500 | [diff] [blame] | 471 | #else |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 472 | exit(EXIT_FAILURE); |
Matt Spinler | f9c83c4 | 2017-08-10 08:51:45 -0500 | [diff] [blame] | 473 | #endif |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 474 | } |
| 475 | } |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 476 | } |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 477 | |
Matthew Barth | 8772ce3 | 2018-03-22 16:03:06 -0500 | [diff] [blame] | 478 | // Remove any sensors marked for removal |
Patrick Venture | db7ecb6 | 2018-10-23 19:42:23 -0700 | [diff] [blame] | 479 | for (const auto& i : rmSensors) |
Deepak Kodihalli | 2a51a9c | 2018-03-07 02:39:40 -0600 | [diff] [blame] | 480 | { |
Matthew Barth | 33db92b | 2018-03-26 09:55:19 -0500 | [diff] [blame] | 481 | state.erase(i.first); |
Brad Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 482 | } |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 483 | |
| 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 Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 492 | std::make_pair(it->first, it->second); |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 493 | auto object = getObject(ssValueType); |
| 494 | if (object) |
Matthew Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 495 | { |
Matthew Barth | d238e23 | 2018-04-17 12:01:50 -0500 | [diff] [blame] | 496 | // 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 Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 506 | // Sensor object added, erase entry from removal list |
Matthew Barth | 38c74e7 | 2018-04-02 12:41:26 -0500 | [diff] [blame] | 507 | auto file = sysfs::make_sysfs_path( |
Patrick Venture | 043d323 | 2018-08-31 10:10:53 -0700 | [diff] [blame] | 508 | 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 Barth | 31d214c | 2018-03-26 09:54:27 -0500 | [diff] [blame] | 512 | 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 Bishop | e55ef3d | 2016-12-19 09:12:40 -0500 | [diff] [blame] | 526 | } |
| 527 | |
| 528 | // vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4 |