blob: a5da1009ad5c5881c00a7f46b898f7a8d0a84c06 [file] [log] [blame]
Patrick Venture863b9242018-03-08 08:29:23 -08001/**
2 * Copyright 2017 Google Inc.
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 */
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070016#include "dbuspassive.hpp"
17
Patrick Ventureaadb30d2020-08-10 09:17:11 -070018#include "dbushelper_interface.hpp"
James Feist98b704e2019-06-03 16:24:53 -070019#include "dbuspassiveredundancy.hpp"
Patrick Ventureaadb30d2020-08-10 09:17:11 -070020#include "dbusutil.hpp"
James Feist0c8223b2019-05-08 15:33:33 -070021#include "util.hpp"
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070022
Patrick Venturea83a3ec2020-08-04 09:52:05 -070023#include <sdbusplus/bus.hpp>
24
Patrick Venture863b9242018-03-08 08:29:23 -080025#include <chrono>
26#include <cmath>
Patrick Venture0ef1faf2018-06-13 12:50:53 -070027#include <memory>
Patrick Venture863b9242018-03-08 08:29:23 -080028#include <mutex>
Patrick Venture0ef1faf2018-06-13 12:50:53 -070029#include <string>
James Feist1f802f52019-02-08 13:51:43 -080030#include <variant>
Patrick Venture863b9242018-03-08 08:29:23 -080031
Patrick Venturea0764872020-08-08 07:48:43 -070032namespace pid_control
33{
34
Patrick Venture563a3562018-10-30 09:31:26 -070035std::unique_ptr<ReadInterface> DbusPassive::createDbusPassive(
Patrick Ventureda4a5dd2018-08-31 09:42:48 -070036 sdbusplus::bus::bus& bus, const std::string& type, const std::string& id,
Patrick Venture8729eb92020-08-10 10:38:44 -070037 std::unique_ptr<DbusHelperInterface> helper, const conf::SensorConfig* info,
James Feist98b704e2019-06-03 16:24:53 -070038 const std::shared_ptr<DbusPassiveRedundancy>& redundancy)
Patrick Venture0ef1faf2018-06-13 12:50:53 -070039{
40 if (helper == nullptr)
41 {
42 return nullptr;
43 }
Patrick Venture7af157b2018-10-30 11:24:40 -070044 if (!validType(type))
Patrick Venture0ef1faf2018-06-13 12:50:53 -070045 {
46 return nullptr;
47 }
48
Patrick Venture863b9242018-03-08 08:29:23 -080049 /* Need to get the scale and initial value */
Patrick Venture863b9242018-03-08 08:29:23 -080050 /* service == busname */
Patrick Venture7af157b2018-10-30 11:24:40 -070051 std::string path = getSensorPath(type, id);
Patrick Venture34ddc902018-10-30 11:05:17 -070052
Patrick Venture1df9e872020-10-08 15:35:01 -070053 SensorProperties settings;
Patrick Venturef8cb4642018-10-30 12:02:53 -070054 bool failed;
Patrick Venture863b9242018-03-08 08:29:23 -080055
Patrick Venturef8cb4642018-10-30 12:02:53 -070056 try
57 {
Patrick Venture9b936922020-08-10 11:28:39 -070058 std::string service = helper->getService(sensorintf, path);
Patrick Venturef8cb4642018-10-30 12:02:53 -070059
Patrick Venture9b936922020-08-10 11:28:39 -070060 helper->getProperties(service, path, &settings);
61 failed = helper->thresholdsAsserted(service, path);
Patrick Venturef8cb4642018-10-30 12:02:53 -070062 }
63 catch (const std::exception& e)
64 {
65 return nullptr;
66 }
67
Patrick Venture6b9f5992019-09-10 09:18:28 -070068 /* if these values are zero, they're ignored. */
69 if (info->ignoreDbusMinMax)
70 {
71 settings.min = 0;
72 settings.max = 0;
73 }
74
Alex.Song8f73ad72021-10-07 00:18:27 +080075 settings.unavailableAsFailed = info->unavailableAsFailed;
76
Patrick Venture8729eb92020-08-10 10:38:44 -070077 return std::make_unique<DbusPassive>(bus, type, id, std::move(helper),
78 settings, failed, path, redundancy);
Patrick Venturef8cb4642018-10-30 12:02:53 -070079}
80
James Feist98b704e2019-06-03 16:24:53 -070081DbusPassive::DbusPassive(
82 sdbusplus::bus::bus& bus, const std::string& type, const std::string& id,
Patrick Venture8729eb92020-08-10 10:38:44 -070083 std::unique_ptr<DbusHelperInterface> helper,
Patrick Venture1df9e872020-10-08 15:35:01 -070084 const SensorProperties& settings, bool failed, const std::string& path,
James Feist98b704e2019-06-03 16:24:53 -070085 const std::shared_ptr<DbusPassiveRedundancy>& redundancy) :
Patrick Venturef8cb4642018-10-30 12:02:53 -070086 ReadInterface(),
Patrick Ventured0571302020-08-10 12:42:23 -070087 _signal(bus, getMatch(type, id).c_str(), dbusHandleSignal, this), _id(id),
88 _helper(std::move(helper)), _failed(failed), path(path),
James Feist98b704e2019-06-03 16:24:53 -070089 redundancy(redundancy)
90
Patrick Venturef8cb4642018-10-30 12:02:53 -070091{
Patrick Venture863b9242018-03-08 08:29:23 -080092 _scale = settings.scale;
Josh Lehan3e2f7582020-09-20 22:06:03 -070093 _min = settings.min * std::pow(10.0, _scale);
94 _max = settings.max * std::pow(10.0, _scale);
Alex.Song8f73ad72021-10-07 00:18:27 +080095 _available = settings.available;
96 _unavailableAsFailed = settings.unavailableAsFailed;
Josh Lehan3e2f7582020-09-20 22:06:03 -070097
98 // Cache this type knowledge, to avoid repeated string comparison
99 _typeMargin = (type == "margin");
Alex.Song8f73ad72021-10-07 00:18:27 +0800100 _typeFan = (type == "fan");
Josh Lehan3e2f7582020-09-20 22:06:03 -0700101
102 // Force value to be stored, otherwise member would be uninitialized
103 updateValue(settings.value, true);
Patrick Venture863b9242018-03-08 08:29:23 -0800104}
105
106ReadReturn DbusPassive::read(void)
107{
108 std::lock_guard<std::mutex> guard(_lock);
109
Patrick Venture1df9e872020-10-08 15:35:01 -0700110 ReadReturn r = {_value, _updated};
Patrick Venture863b9242018-03-08 08:29:23 -0800111
112 return r;
113}
114
115void DbusPassive::setValue(double value)
116{
117 std::lock_guard<std::mutex> guard(_lock);
118
119 _value = value;
120 _updated = std::chrono::high_resolution_clock::now();
121}
122
James Feist36b7d8e2018-10-05 15:39:01 -0700123bool DbusPassive::getFailed(void) const
124{
James Feist98b704e2019-06-03 16:24:53 -0700125 if (redundancy)
126 {
127 const std::set<std::string>& failures = redundancy->getFailed();
128 if (failures.find(path) != failures.end())
129 {
130 return true;
131 }
132 }
James Feist4b36f262020-07-07 16:56:41 -0700133
Alex.Song8f73ad72021-10-07 00:18:27 +0800134 /*
135 * Unavailable thermal sensors, who are not present or
136 * power-state-not-matching, should not trigger the failSafe mode. For
137 * example, when a system stays at a powered-off state, its CPU Temp
138 * sensors will be unavailable, these unavailable sensors should not be
139 * treated as failed and trigger failSafe.
140 * This is important for systems whose Fans are always on.
141 */
142 if (!_typeFan && !_available && !_unavailableAsFailed)
143 {
144 return false;
145 }
146
Josh Lehan3e2f7582020-09-20 22:06:03 -0700147 // If a reading has came in,
148 // but its value bad in some way (determined by sensor type),
149 // indicate this sensor has failed,
150 // until another value comes in that is no longer bad.
151 // This is different from the overall _failed flag,
152 // which is set and cleared by other causes.
153 if (_badReading)
154 {
155 return true;
156 }
157
158 // If a reading has came in, and it is not a bad reading,
159 // but it indicates there is no more thermal margin left,
160 // that is bad, something is wrong with the PID loops,
161 // they are not cooling the system, enable failsafe mode also.
162 if (_marginHot)
163 {
164 return true;
165 }
166
Alex.Song8f73ad72021-10-07 00:18:27 +0800167 return _failed || !_available || !_functional;
James Feist36b7d8e2018-10-05 15:39:01 -0700168}
169
170void DbusPassive::setFailed(bool value)
171{
172 _failed = value;
173}
174
James Feist4b36f262020-07-07 16:56:41 -0700175void DbusPassive::setFunctional(bool value)
176{
177 _functional = value;
178}
179
Alex.Song8f73ad72021-10-07 00:18:27 +0800180void DbusPassive::setAvailable(bool value)
181{
182 _available = value;
183}
184
Patrick Venture863b9242018-03-08 08:29:23 -0800185int64_t DbusPassive::getScale(void)
186{
187 return _scale;
188}
189
Patrick Venture563a3562018-10-30 09:31:26 -0700190std::string DbusPassive::getID(void)
Patrick Venture863b9242018-03-08 08:29:23 -0800191{
192 return _id;
193}
194
James Feist75eb7692019-02-25 12:50:02 -0800195double DbusPassive::getMax(void)
196{
197 return _max;
198}
199
200double DbusPassive::getMin(void)
201{
202 return _min;
203}
204
Josh Lehan3e2f7582020-09-20 22:06:03 -0700205void DbusPassive::updateValue(double value, bool force)
206{
207 _badReading = false;
208
209 // Do not let a NAN, or other floating-point oddity, be used to update
210 // the value, as that indicates the sensor has no valid reading.
211 if (!(std::isfinite(value)))
212 {
213 _badReading = true;
214
215 // Do not continue with a bad reading, unless caller forcing
216 if (!force)
217 {
218 return;
219 }
220 }
221
222 value *= std::pow(10.0, _scale);
223
224 auto unscaled = value;
225 scaleSensorReading(_min, _max, value);
226
227 if (_typeMargin)
228 {
229 _marginHot = false;
230
231 // Unlike an absolute temperature sensor,
232 // where 0 degrees C is a good reading,
233 // a value received of 0 (or negative) margin is worrisome,
234 // and should be flagged.
235 // Either it indicates margin not calculated properly,
236 // or somebody forgot to set the margin-zero setpoint,
237 // or the system is really overheating that much.
238 // This is a different condition from _failed
239 // and _badReading, so it merits its own flag.
240 // The sensor has not failed, the reading is good, but the zone
241 // still needs to know that it should go to failsafe mode.
242 if (unscaled <= 0.0)
243 {
244 _marginHot = true;
245 }
246 }
247
248 setValue(value);
249}
250
Patrick Venture7af157b2018-10-30 11:24:40 -0700251int handleSensorValue(sdbusplus::message::message& msg, DbusPassive* owner)
Patrick Venture863b9242018-03-08 08:29:23 -0800252{
Patrick Venture863b9242018-03-08 08:29:23 -0800253 std::string msgSensor;
James Feist1f802f52019-02-08 13:51:43 -0800254 std::map<std::string, std::variant<int64_t, double, bool>> msgData;
Patrick Ventured0c75662018-06-12 19:03:21 -0700255
256 msg.read(msgSensor, msgData);
Patrick Venture863b9242018-03-08 08:29:23 -0800257
258 if (msgSensor == "xyz.openbmc_project.Sensor.Value")
259 {
260 auto valPropMap = msgData.find("Value");
261 if (valPropMap != msgData.end())
262 {
James Feist1f802f52019-02-08 13:51:43 -0800263 double value =
264 std::visit(VariantToDoubleVisitor(), valPropMap->second);
Patrick Venture863b9242018-03-08 08:29:23 -0800265
Josh Lehan3e2f7582020-09-20 22:06:03 -0700266 owner->updateValue(value, false);
Patrick Venture863b9242018-03-08 08:29:23 -0800267 }
268 }
James Feist36b7d8e2018-10-05 15:39:01 -0700269 else if (msgSensor == "xyz.openbmc_project.Sensor.Threshold.Critical")
270 {
271 auto criticalAlarmLow = msgData.find("CriticalAlarmLow");
272 auto criticalAlarmHigh = msgData.find("CriticalAlarmHigh");
273 if (criticalAlarmHigh == msgData.end() &&
274 criticalAlarmLow == msgData.end())
275 {
276 return 0;
277 }
278
279 bool asserted = false;
280 if (criticalAlarmLow != msgData.end())
281 {
James Feist1f802f52019-02-08 13:51:43 -0800282 asserted = std::get<bool>(criticalAlarmLow->second);
James Feist36b7d8e2018-10-05 15:39:01 -0700283 }
284
285 // checking both as in theory you could de-assert one threshold and
286 // assert the other at the same moment
287 if (!asserted && criticalAlarmHigh != msgData.end())
288 {
James Feist1f802f52019-02-08 13:51:43 -0800289 asserted = std::get<bool>(criticalAlarmHigh->second);
James Feist36b7d8e2018-10-05 15:39:01 -0700290 }
291 owner->setFailed(asserted);
292 }
Alex.Song8f73ad72021-10-07 00:18:27 +0800293 else if (msgSensor == "xyz.openbmc_project.State.Decorator.Availability")
294 {
295 auto available = msgData.find("Available");
296 if (available == msgData.end())
297 {
298 return 0;
299 }
300 bool asserted = std::get<bool>(available->second);
301 owner->setAvailable(asserted);
302 if (!asserted)
303 {
304 // A thermal controller will continue its PID calculation and not
305 // trigger a 'failsafe' when some inputs are unavailable.
306 // So, forced to clear the value here to prevent a historical
307 // value to participate in a latter PID calculation.
308 owner->updateValue(std::numeric_limits<double>::quiet_NaN(), true);
309 }
310 }
James Feist4b36f262020-07-07 16:56:41 -0700311 else if (msgSensor ==
312 "xyz.openbmc_project.State.Decorator.OperationalStatus")
313 {
314 auto functional = msgData.find("Functional");
315 if (functional == msgData.end())
316 {
317 return 0;
318 }
319 bool asserted = std::get<bool>(functional->second);
320 owner->setFunctional(asserted);
321 }
Patrick Venture863b9242018-03-08 08:29:23 -0800322
323 return 0;
324}
Patrick Ventured0c75662018-06-12 19:03:21 -0700325
Patrick Venture7af157b2018-10-30 11:24:40 -0700326int dbusHandleSignal(sd_bus_message* msg, void* usrData, sd_bus_error* err)
Patrick Ventured0c75662018-06-12 19:03:21 -0700327{
328 auto sdbpMsg = sdbusplus::message::message(msg);
329 DbusPassive* obj = static_cast<DbusPassive*>(usrData);
330
Patrick Venture7af157b2018-10-30 11:24:40 -0700331 return handleSensorValue(sdbpMsg, obj);
Patrick Ventured0c75662018-06-12 19:03:21 -0700332}
Patrick Venturea0764872020-08-08 07:48:43 -0700333
334} // namespace pid_control