blob: ac0d5cf7df506611c39ddb244dbaff8708d9e97c [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 Williamsb228bc32022-07-22 19:26:56 -050036 sdbusplus::bus_t& 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 */
Harvey.Wuf2efcbb2022-02-09 10:24:30 +080051 std::string path;
52 if (info->readPath.empty())
53 {
54 path = getSensorPath(type, id);
55 }
56 else
57 {
58 path = info->readPath;
59 }
Patrick Venture34ddc902018-10-30 11:05:17 -070060
Patrick Venture1df9e872020-10-08 15:35:01 -070061 SensorProperties settings;
Patrick Venturef8cb4642018-10-30 12:02:53 -070062 bool failed;
Patrick Venture863b9242018-03-08 08:29:23 -080063
Patrick Venturef8cb4642018-10-30 12:02:53 -070064 try
65 {
Patrick Venture9b936922020-08-10 11:28:39 -070066 std::string service = helper->getService(sensorintf, path);
Patrick Venturef8cb4642018-10-30 12:02:53 -070067
Patrick Venture9b936922020-08-10 11:28:39 -070068 helper->getProperties(service, path, &settings);
69 failed = helper->thresholdsAsserted(service, path);
Patrick Venturef8cb4642018-10-30 12:02:53 -070070 }
71 catch (const std::exception& e)
72 {
73 return nullptr;
74 }
75
Patrick Venture6b9f5992019-09-10 09:18:28 -070076 /* if these values are zero, they're ignored. */
77 if (info->ignoreDbusMinMax)
78 {
79 settings.min = 0;
80 settings.max = 0;
81 }
82
Alex.Song8f73ad72021-10-07 00:18:27 +080083 settings.unavailableAsFailed = info->unavailableAsFailed;
84
Patrick Venture8729eb92020-08-10 10:38:44 -070085 return std::make_unique<DbusPassive>(bus, type, id, std::move(helper),
86 settings, failed, path, redundancy);
Patrick Venturef8cb4642018-10-30 12:02:53 -070087}
88
James Feist98b704e2019-06-03 16:24:53 -070089DbusPassive::DbusPassive(
Patrick Williamsb228bc32022-07-22 19:26:56 -050090 sdbusplus::bus_t& bus, const std::string& type, const std::string& id,
Patrick Venture8729eb92020-08-10 10:38:44 -070091 std::unique_ptr<DbusHelperInterface> helper,
Patrick Venture1df9e872020-10-08 15:35:01 -070092 const SensorProperties& settings, bool failed, const std::string& path,
James Feist98b704e2019-06-03 16:24:53 -070093 const std::shared_ptr<DbusPassiveRedundancy>& redundancy) :
Patrick Venturef8cb4642018-10-30 12:02:53 -070094 ReadInterface(),
Patrick Williamsd5d83fa2023-07-13 17:40:57 -050095 _signal(bus, getMatch(path), dbusHandleSignal, this), _id(id),
Patrick Ventured0571302020-08-10 12:42:23 -070096 _helper(std::move(helper)), _failed(failed), path(path),
James Feist98b704e2019-06-03 16:24:53 -070097 redundancy(redundancy)
98
Patrick Venturef8cb4642018-10-30 12:02:53 -070099{
Patrick Venture863b9242018-03-08 08:29:23 -0800100 _scale = settings.scale;
Josh Lehan3e2f7582020-09-20 22:06:03 -0700101 _min = settings.min * std::pow(10.0, _scale);
102 _max = settings.max * std::pow(10.0, _scale);
Alex.Song8f73ad72021-10-07 00:18:27 +0800103 _available = settings.available;
104 _unavailableAsFailed = settings.unavailableAsFailed;
Josh Lehan3e2f7582020-09-20 22:06:03 -0700105
106 // Cache this type knowledge, to avoid repeated string comparison
107 _typeMargin = (type == "margin");
Alex.Song8f73ad72021-10-07 00:18:27 +0800108 _typeFan = (type == "fan");
Josh Lehan3e2f7582020-09-20 22:06:03 -0700109
110 // Force value to be stored, otherwise member would be uninitialized
111 updateValue(settings.value, true);
Patrick Venture863b9242018-03-08 08:29:23 -0800112}
113
114ReadReturn DbusPassive::read(void)
115{
116 std::lock_guard<std::mutex> guard(_lock);
117
Josh Lehanb3005752022-02-22 20:48:07 -0800118 ReadReturn r = {_value, _updated, _unscaled};
Patrick Venture863b9242018-03-08 08:29:23 -0800119
120 return r;
121}
122
Josh Lehanb3005752022-02-22 20:48:07 -0800123void DbusPassive::setValue(double value, double unscaled)
Patrick Venture863b9242018-03-08 08:29:23 -0800124{
125 std::lock_guard<std::mutex> guard(_lock);
126
127 _value = value;
Josh Lehanb3005752022-02-22 20:48:07 -0800128 _unscaled = unscaled;
Patrick Venture863b9242018-03-08 08:29:23 -0800129 _updated = std::chrono::high_resolution_clock::now();
130}
131
Josh Lehanb3005752022-02-22 20:48:07 -0800132void DbusPassive::setValue(double value)
133{
134 // First param is scaled, second param is unscaled, assume same here
135 setValue(value, value);
136}
137
James Feist36b7d8e2018-10-05 15:39:01 -0700138bool DbusPassive::getFailed(void) const
139{
James Feist98b704e2019-06-03 16:24:53 -0700140 if (redundancy)
141 {
142 const std::set<std::string>& failures = redundancy->getFailed();
143 if (failures.find(path) != failures.end())
144 {
145 return true;
146 }
147 }
James Feist4b36f262020-07-07 16:56:41 -0700148
Alex.Song8f73ad72021-10-07 00:18:27 +0800149 /*
150 * Unavailable thermal sensors, who are not present or
151 * power-state-not-matching, should not trigger the failSafe mode. For
152 * example, when a system stays at a powered-off state, its CPU Temp
153 * sensors will be unavailable, these unavailable sensors should not be
154 * treated as failed and trigger failSafe.
155 * This is important for systems whose Fans are always on.
156 */
157 if (!_typeFan && !_available && !_unavailableAsFailed)
158 {
159 return false;
160 }
161
Josh Lehan3e2f7582020-09-20 22:06:03 -0700162 // If a reading has came in,
163 // but its value bad in some way (determined by sensor type),
164 // indicate this sensor has failed,
165 // until another value comes in that is no longer bad.
166 // This is different from the overall _failed flag,
167 // which is set and cleared by other causes.
168 if (_badReading)
169 {
170 return true;
171 }
172
173 // If a reading has came in, and it is not a bad reading,
174 // but it indicates there is no more thermal margin left,
175 // that is bad, something is wrong with the PID loops,
176 // they are not cooling the system, enable failsafe mode also.
177 if (_marginHot)
178 {
179 return true;
180 }
181
Alex.Song8f73ad72021-10-07 00:18:27 +0800182 return _failed || !_available || !_functional;
James Feist36b7d8e2018-10-05 15:39:01 -0700183}
184
185void DbusPassive::setFailed(bool value)
186{
187 _failed = value;
188}
189
James Feist4b36f262020-07-07 16:56:41 -0700190void DbusPassive::setFunctional(bool value)
191{
192 _functional = value;
193}
194
Alex.Song8f73ad72021-10-07 00:18:27 +0800195void DbusPassive::setAvailable(bool value)
196{
197 _available = value;
198}
199
Patrick Venture863b9242018-03-08 08:29:23 -0800200int64_t DbusPassive::getScale(void)
201{
202 return _scale;
203}
204
Patrick Venture563a3562018-10-30 09:31:26 -0700205std::string DbusPassive::getID(void)
Patrick Venture863b9242018-03-08 08:29:23 -0800206{
207 return _id;
208}
209
James Feist75eb7692019-02-25 12:50:02 -0800210double DbusPassive::getMax(void)
211{
212 return _max;
213}
214
215double DbusPassive::getMin(void)
216{
217 return _min;
218}
219
Josh Lehan3e2f7582020-09-20 22:06:03 -0700220void DbusPassive::updateValue(double value, bool force)
221{
222 _badReading = false;
223
224 // Do not let a NAN, or other floating-point oddity, be used to update
225 // the value, as that indicates the sensor has no valid reading.
226 if (!(std::isfinite(value)))
227 {
228 _badReading = true;
229
230 // Do not continue with a bad reading, unless caller forcing
231 if (!force)
232 {
233 return;
234 }
235 }
236
237 value *= std::pow(10.0, _scale);
238
239 auto unscaled = value;
240 scaleSensorReading(_min, _max, value);
241
242 if (_typeMargin)
243 {
244 _marginHot = false;
245
246 // Unlike an absolute temperature sensor,
247 // where 0 degrees C is a good reading,
248 // a value received of 0 (or negative) margin is worrisome,
249 // and should be flagged.
250 // Either it indicates margin not calculated properly,
251 // or somebody forgot to set the margin-zero setpoint,
252 // or the system is really overheating that much.
253 // This is a different condition from _failed
254 // and _badReading, so it merits its own flag.
255 // The sensor has not failed, the reading is good, but the zone
256 // still needs to know that it should go to failsafe mode.
257 if (unscaled <= 0.0)
258 {
259 _marginHot = true;
260 }
261 }
262
Josh Lehanb3005752022-02-22 20:48:07 -0800263 setValue(value, unscaled);
Josh Lehan3e2f7582020-09-20 22:06:03 -0700264}
265
Patrick Williamsb228bc32022-07-22 19:26:56 -0500266int handleSensorValue(sdbusplus::message_t& msg, DbusPassive* owner)
Patrick Venture863b9242018-03-08 08:29:23 -0800267{
Patrick Venture863b9242018-03-08 08:29:23 -0800268 std::string msgSensor;
James Feist1f802f52019-02-08 13:51:43 -0800269 std::map<std::string, std::variant<int64_t, double, bool>> msgData;
Patrick Ventured0c75662018-06-12 19:03:21 -0700270
271 msg.read(msgSensor, msgData);
Patrick Venture863b9242018-03-08 08:29:23 -0800272
273 if (msgSensor == "xyz.openbmc_project.Sensor.Value")
274 {
275 auto valPropMap = msgData.find("Value");
276 if (valPropMap != msgData.end())
277 {
Patrick Williams8c051122023-05-10 07:50:59 -0500278 double value = std::visit(VariantToDoubleVisitor(),
279 valPropMap->second);
Patrick Venture863b9242018-03-08 08:29:23 -0800280
Josh Lehan3e2f7582020-09-20 22:06:03 -0700281 owner->updateValue(value, false);
Patrick Venture863b9242018-03-08 08:29:23 -0800282 }
283 }
James Feist36b7d8e2018-10-05 15:39:01 -0700284 else if (msgSensor == "xyz.openbmc_project.Sensor.Threshold.Critical")
285 {
286 auto criticalAlarmLow = msgData.find("CriticalAlarmLow");
287 auto criticalAlarmHigh = msgData.find("CriticalAlarmHigh");
288 if (criticalAlarmHigh == msgData.end() &&
289 criticalAlarmLow == msgData.end())
290 {
291 return 0;
292 }
293
294 bool asserted = false;
295 if (criticalAlarmLow != msgData.end())
296 {
James Feist1f802f52019-02-08 13:51:43 -0800297 asserted = std::get<bool>(criticalAlarmLow->second);
James Feist36b7d8e2018-10-05 15:39:01 -0700298 }
299
300 // checking both as in theory you could de-assert one threshold and
301 // assert the other at the same moment
302 if (!asserted && criticalAlarmHigh != msgData.end())
303 {
James Feist1f802f52019-02-08 13:51:43 -0800304 asserted = std::get<bool>(criticalAlarmHigh->second);
James Feist36b7d8e2018-10-05 15:39:01 -0700305 }
306 owner->setFailed(asserted);
307 }
Alex.Song8f73ad72021-10-07 00:18:27 +0800308 else if (msgSensor == "xyz.openbmc_project.State.Decorator.Availability")
309 {
310 auto available = msgData.find("Available");
311 if (available == msgData.end())
312 {
313 return 0;
314 }
315 bool asserted = std::get<bool>(available->second);
316 owner->setAvailable(asserted);
317 if (!asserted)
318 {
319 // A thermal controller will continue its PID calculation and not
320 // trigger a 'failsafe' when some inputs are unavailable.
321 // So, forced to clear the value here to prevent a historical
322 // value to participate in a latter PID calculation.
323 owner->updateValue(std::numeric_limits<double>::quiet_NaN(), true);
324 }
325 }
James Feist4b36f262020-07-07 16:56:41 -0700326 else if (msgSensor ==
327 "xyz.openbmc_project.State.Decorator.OperationalStatus")
328 {
329 auto functional = msgData.find("Functional");
330 if (functional == msgData.end())
331 {
332 return 0;
333 }
334 bool asserted = std::get<bool>(functional->second);
335 owner->setFunctional(asserted);
336 }
Patrick Venture863b9242018-03-08 08:29:23 -0800337
338 return 0;
339}
Patrick Ventured0c75662018-06-12 19:03:21 -0700340
Harvey.Wua1ae4fa2022-10-28 17:38:35 +0800341int dbusHandleSignal(sd_bus_message* msg, void* usrData,
342 [[maybe_unused]] sd_bus_error* err)
Patrick Ventured0c75662018-06-12 19:03:21 -0700343{
Patrick Williamsb228bc32022-07-22 19:26:56 -0500344 auto sdbpMsg = sdbusplus::message_t(msg);
Patrick Ventured0c75662018-06-12 19:03:21 -0700345 DbusPassive* obj = static_cast<DbusPassive*>(usrData);
346
Patrick Venture7af157b2018-10-30 11:24:40 -0700347 return handleSensorValue(sdbpMsg, obj);
Patrick Ventured0c75662018-06-12 19:03:21 -0700348}
Patrick Venturea0764872020-08-08 07:48:43 -0700349
350} // namespace pid_control