xref: /openbmc/dbus-sensors/src/sensor.hpp (revision 6198435dc2bc6e07b46e32465876815d4ea86437) 
1 #pragma once
2 
3 #include "dbus-sensor_config.h"
4 
5 #include "SensorPaths.hpp"
6 #include "Thresholds.hpp"
7 #include "Utils.hpp"
8 
9 #include <phosphor-logging/lg2.hpp>
10 #include <sdbusplus/asio/connection.hpp>
11 #include <sdbusplus/asio/object_server.hpp>
12 #include <sdbusplus/exception.hpp>
13 
14 #include <array>
15 #include <cerrno>
16 #include <cmath>
17 #include <cstddef>
18 #include <cstdlib>
19 #include <functional>
20 #include <limits>
21 #include <memory>
22 #include <string>
23 #include <utility>
24 #include <vector>
25 
26 constexpr size_t sensorFailedPollTimeMs = 5000;
27 
28 // Enable useful logging with sensor instrumentation
29 // This is intentionally not DEBUG, avoid clash with usage in .cpp files
30 constexpr bool enableInstrumentation = false;
31 
32 constexpr const char* sensorValueInterface = "xyz.openbmc_project.Sensor.Value";
33 constexpr const char* valueMutabilityInterfaceName =
34     "xyz.openbmc_project.Sensor.ValueMutability";
35 constexpr const char* availableInterfaceName =
36     "xyz.openbmc_project.State.Decorator.Availability";
37 constexpr const char* operationalInterfaceName =
38     "xyz.openbmc_project.State.Decorator.OperationalStatus";
39 constexpr const size_t errorThreshold = 5;
40 
41 struct SensorInstrumentation
42 {
43     // These are for instrumentation for debugging
44     int numCollectsGood = 0;
45     int numCollectsMiss = 0;
46     int numStreakGreats = 0;
47     int numStreakMisses = 0;
48     double minCollected = 0.0;
49     double maxCollected = 0.0;
50 };
51 
52 struct SetSensorError : sdbusplus::exception_t
53 {
nameSetSensorError54     const char* name() const noexcept override
55     {
56         return "xyz.openbmc_project.Common.Errors.NotAllowed";
57     }
descriptionSetSensorError58     const char* description() const noexcept override
59     {
60         return "Not allowed to set property value.";
61     }
get_errnoSetSensorError62     int get_errno() const noexcept override
63     {
64         return EACCES;
65     }
66 };
67 
68 struct Sensor
69 {
SensorSensor70     Sensor(const std::string& name,
71            std::vector<thresholds::Threshold>&& thresholdData,
72            const std::string& configurationPath, const std::string& objectType,
73            bool isSettable, bool isMutable, const double max, const double min,
74            std::shared_ptr<sdbusplus::asio::connection>& conn,
75            PowerState readState = PowerState::always) :
76         name(sensor_paths::escapePathForDbus(name)),
77         configurationPath(configurationPath),
78         configInterface(configInterfaceName(objectType)),
79         isSensorSettable(isSettable), isValueMutable(isMutable), maxValue(max),
80         minValue(min), thresholds(std::move(thresholdData)),
81         hysteresisTrigger((max - min) * 0.01),
82         hysteresisPublish((max - min) * 0.0001), dbusConnection(conn),
83         readState(readState),
84         instrumentation(enableInstrumentation
85                             ? std::make_unique<SensorInstrumentation>()
86                             : nullptr)
87     {}
88     virtual ~Sensor() = default;
89     virtual void checkThresholds() = 0;
90     std::string name;
91     std::string configurationPath;
92     std::string configInterface;
93     bool isSensorSettable;
94 
95     /* A flag indicates if properties of xyz.openbmc_project.Sensor.Value
96      * interface are mutable. If mutable, then
97      * xyz.openbmc_project.Sensor.ValueMutability interface will be
98      * instantiated.
99      */
100     bool isValueMutable;
101     double maxValue;
102     double minValue;
103     std::vector<thresholds::Threshold> thresholds;
104     std::shared_ptr<sdbusplus::asio::dbus_interface> sensorInterface;
105     std::shared_ptr<sdbusplus::asio::dbus_interface> association;
106     std::shared_ptr<sdbusplus::asio::dbus_interface> availableInterface;
107     std::shared_ptr<sdbusplus::asio::dbus_interface> operationalInterface;
108     std::shared_ptr<sdbusplus::asio::dbus_interface> valueMutabilityInterface;
109     double value = std::numeric_limits<double>::quiet_NaN();
110     double rawValue = std::numeric_limits<double>::quiet_NaN();
111     bool overriddenState = false;
112     bool internalSet = false;
113     double hysteresisTrigger;
114     double hysteresisPublish;
115     std::shared_ptr<sdbusplus::asio::connection> dbusConnection;
116     PowerState readState;
117     size_t errCount{0};
118     std::unique_ptr<SensorInstrumentation> instrumentation;
119 
120     // This member variable provides a hook that can be used to receive
121     // notification whenever this Sensor's value is externally set via D-Bus.
122     // If interested, assign your own lambda to this variable, during
123     // construction of your Sensor subclass. See ExternalSensor for example.
124     std::function<void()> externalSetHook;
125 
126     using Level = thresholds::Level;
127     using Direction = thresholds::Direction;
128 
129     std::array<std::shared_ptr<sdbusplus::asio::dbus_interface>,
130                thresholds::thresProp.size()>
131         thresholdInterfaces;
132 
getThresholdInterfaceSensor133     std::shared_ptr<sdbusplus::asio::dbus_interface> getThresholdInterface(
134         Level lev)
135     {
136         size_t index = static_cast<size_t>(lev);
137         if (index >= thresholdInterfaces.size())
138         {
139             lg2::info("Unknown threshold level");
140             return nullptr;
141         }
142         std::shared_ptr<sdbusplus::asio::dbus_interface> interface =
143             thresholdInterfaces[index];
144         return interface;
145     }
146 
updateInstrumentationSensor147     void updateInstrumentation(double readValue) const
148     {
149         // Do nothing if this feature is not enabled
150         if constexpr (!enableInstrumentation)
151         {
152             return;
153         }
154         if (!instrumentation)
155         {
156             return;
157         }
158 
159         // Save some typing
160         auto& inst = *instrumentation;
161 
162         // Show constants if first reading (even if unsuccessful)
163         if ((inst.numCollectsGood == 0) && (inst.numCollectsMiss == 0))
164         {
165             lg2::info(
166                 "Sensor name: {NAME}, min: {MIN}, max: {MAX}, type: {TYPE}, path: {PATH}",
167                 "NAME", name, "MIN", minValue, "MAX", maxValue, "TYPE",
168                 configInterface, "PATH", configurationPath);
169         }
170 
171         // Sensors can use "nan" to indicate unavailable reading
172         if (!std::isfinite(readValue))
173         {
174             // Only show this if beginning a new streak
175             if (inst.numStreakMisses == 0)
176             {
177                 lg2::warning(
178                     "Sensor name: {NAME}, Missing reading, Reading counts good= {NUM_COLLECTS_GOOD},"
179                     " miss= {NUM_COLLECTS_MISS}, Prior good streak= {NUM_STREAK_GREATS}",
180                     "NAME", name, "NUM_COLLECTS_GOOD", inst.numCollectsGood,
181                     "NUM_COLLECTS_MISS", inst.numCollectsMiss,
182                     "NUM_STREAK_GREATS", inst.numStreakGreats);
183             }
184 
185             inst.numStreakGreats = 0;
186             ++(inst.numCollectsMiss);
187             ++(inst.numStreakMisses);
188 
189             return;
190         }
191 
192         // Only show this if beginning a new streak and not the first time
193         if ((inst.numStreakGreats == 0) && (inst.numCollectsGood != 0))
194         {
195             lg2::info(
196                 "Sensor name: {NAME}, Recovered reading, Reading counts good= {NUM_COLLECTS_GOOD},"
197                 " miss= {NUM_COLLECTS_MISS}, Prior good streak= {NUM_STREAK_GREATS}",
198                 "NAME", name, "NUM_COLLECTS_GOOD", inst.numCollectsGood,
199                 "NUM_COLLECTS_MISS", inst.numCollectsMiss, "NUM_STREAK_GREATS",
200                 inst.numStreakGreats);
201         }
202 
203         // Initialize min/max if the first successful reading
204         if (inst.numCollectsGood == 0)
205         {
206             lg2::info("Sensor name: {NAME}, First reading: {VALUE}", "NAME",
207                       name, "VALUE", readValue);
208 
209             inst.minCollected = readValue;
210             inst.maxCollected = readValue;
211         }
212 
213         inst.numStreakMisses = 0;
214         ++(inst.numCollectsGood);
215         ++(inst.numStreakGreats);
216 
217         // Only provide subsequent output if new min/max established
218         if (readValue < inst.minCollected)
219         {
220             lg2::info("Sensor name: {NAME}, Lowest reading: {VALUE}", "NAME",
221                       name, "VALUE", readValue);
222 
223             inst.minCollected = readValue;
224         }
225 
226         if (readValue > inst.maxCollected)
227         {
228             lg2::info("Sensor name: {NAME}, Highest reading: {VALUE}", "NAME",
229                       name, "VALUE", readValue);
230 
231             inst.maxCollected = readValue;
232         }
233     }
234 
setSensorValueSensor235     int setSensorValue(const double& newValue, double& oldValue)
236     {
237         if (!internalSet)
238         {
239             if (insecureSensorOverride == 0 && !isSensorSettable &&
240                 !getManufacturingMode())
241             {
242                 throw SetSensorError();
243             }
244 
245             oldValue = newValue;
246             overriddenState = true;
247             // check thresholds for external set
248             value = newValue;
249             checkThresholds();
250 
251             // Trigger the hook, as an external set has just happened
252             if (externalSetHook)
253             {
254                 externalSetHook();
255             }
256         }
257         else if (!overriddenState)
258         {
259             oldValue = newValue;
260         }
261         return 1;
262     }
263 
setInitialPropertiesSensor264     void setInitialProperties(const std::string& unit,
265                               const std::string& label = std::string(),
266                               size_t thresholdSize = 0)
267     {
268         if (readState == PowerState::on || readState == PowerState::biosPost ||
269             readState == PowerState::chassisOn)
270         {
271             setupPowerMatch(dbusConnection);
272         }
273 
274         createAssociation(association, configurationPath);
275 
276         sensorInterface->register_property("Unit", unit);
277         sensorInterface->register_property("MaxValue", maxValue);
278         sensorInterface->register_property("MinValue", minValue);
279         sensorInterface->register_property(
280             "Value", value, [this](const double& newValue, double& oldValue) {
281                 return setSensorValue(newValue, oldValue);
282             });
283 
284         fillMissingThresholds();
285 
286         for (auto& threshold : thresholds)
287         {
288             if (std::isnan(threshold.hysteresis))
289             {
290                 threshold.hysteresis = hysteresisTrigger;
291             }
292 
293             std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
294                 getThresholdInterface(threshold.level);
295 
296             if (!iface)
297             {
298                 lg2::info("trying to set uninitialized interface");
299                 continue;
300             }
301 
302             std::string level =
303                 propertyLevel(threshold.level, threshold.direction);
304             std::string alarm =
305                 propertyAlarm(threshold.level, threshold.direction);
306 
307             if ((level.empty()) || (alarm.empty()))
308             {
309                 continue;
310             }
311             size_t thresSize =
312                 label.empty() ? thresholds.size() : thresholdSize;
313             iface->register_property(
314                 level, threshold.value,
315                 [&, label, thresSize](const double& request, double& oldValue) {
316                     oldValue = request; // todo, just let the config do this?
317                     threshold.value = request;
318                     thresholds::persistThreshold(
319                         configurationPath, configInterface, threshold,
320                         dbusConnection, thresSize, label);
321                     // Invalidate previously remembered value,
322                     // so new thresholds will be checked during next update,
323                     // even if sensor reading remains unchanged.
324                     value = std::numeric_limits<double>::quiet_NaN();
325 
326                     // Although tempting, don't call checkThresholds() from here
327                     // directly. Let the regular sensor monitor call the same
328                     // using updateValue(), which can check conditions like
329                     // poweron, etc., before raising any event.
330                     return 1;
331                 });
332             iface->register_property(alarm, false);
333         }
334         if (!sensorInterface->initialize())
335         {
336             lg2::error("error initializing value interface");
337         }
338 
339         for (auto& thresIface : thresholdInterfaces)
340         {
341             if (thresIface)
342             {
343                 if (!thresIface->initialize(true))
344                 {
345                     lg2::error("Error initializing threshold interface");
346                 }
347             }
348         }
349 
350         if (isValueMutable)
351         {
352             valueMutabilityInterface =
353                 std::make_shared<sdbusplus::asio::dbus_interface>(
354                     dbusConnection, sensorInterface->get_object_path(),
355                     valueMutabilityInterfaceName);
356             valueMutabilityInterface->register_property("Mutable", true);
357             if (!valueMutabilityInterface->initialize())
358             {
359                 lg2::error(
360                     "error initializing sensor value mutability interface");
361                 valueMutabilityInterface = nullptr;
362             }
363         }
364 
365         if (!availableInterface)
366         {
367             availableInterface =
368                 std::make_shared<sdbusplus::asio::dbus_interface>(
369                     dbusConnection, sensorInterface->get_object_path(),
370                     availableInterfaceName);
371             availableInterface->register_property(
372                 "Available", true, [this](const bool propIn, bool& old) {
373                     if (propIn == old)
374                     {
375                         return 1;
376                     }
377                     old = propIn;
378                     if (!propIn)
379                     {
380                         updateValue(std::numeric_limits<double>::quiet_NaN());
381                     }
382                     return 1;
383                 });
384             availableInterface->initialize();
385         }
386         if (!operationalInterface)
387         {
388             operationalInterface =
389                 std::make_shared<sdbusplus::asio::dbus_interface>(
390                     dbusConnection, sensorInterface->get_object_path(),
391                     operationalInterfaceName);
392             operationalInterface->register_property("Functional", true);
393             operationalInterface->initialize();
394         }
395     }
396 
propertyLevelSensor397     static std::string propertyLevel(const Level lev, const Direction dir)
398     {
399         for (const thresholds::ThresholdDefinition& prop :
400              thresholds::thresProp)
401         {
402             if (prop.level == lev)
403             {
404                 if (dir == Direction::HIGH)
405                 {
406                     return std::string(prop.levelName) + "High";
407                 }
408                 if (dir == Direction::LOW)
409                 {
410                     return std::string(prop.levelName) + "Low";
411                 }
412             }
413         }
414         return "";
415     }
416 
propertyAlarmSensor417     static std::string propertyAlarm(const Level lev, const Direction dir)
418     {
419         for (const thresholds::ThresholdDefinition& prop :
420              thresholds::thresProp)
421         {
422             if (prop.level == lev)
423             {
424                 if (dir == Direction::HIGH)
425                 {
426                     return std::string(prop.levelName) + "AlarmHigh";
427                 }
428                 if (dir == Direction::LOW)
429                 {
430                     return std::string(prop.levelName) + "AlarmLow";
431                 }
432             }
433         }
434         return "";
435     }
436 
readingStateGoodSensor437     bool readingStateGood() const
438     {
439         return ::readingStateGood(readState);
440     }
441 
markFunctionalSensor442     void markFunctional(bool isFunctional)
443     {
444         if (operationalInterface)
445         {
446             operationalInterface->set_property("Functional", isFunctional);
447         }
448         if (isFunctional)
449         {
450             errCount = 0;
451         }
452         else
453         {
454             updateValue(std::numeric_limits<double>::quiet_NaN());
455         }
456     }
457 
markAvailableSensor458     void markAvailable(bool isAvailable)
459     {
460         if (availableInterface)
461         {
462             availableInterface->set_property("Available", isAvailable);
463             errCount = 0;
464         }
465     }
466 
incrementErrorSensor467     void incrementError()
468     {
469         if (!readingStateGood())
470         {
471             markAvailable(false);
472             return;
473         }
474 
475         if (errCount >= errorThreshold)
476         {
477             return;
478         }
479 
480         errCount++;
481         if (errCount == errorThreshold)
482         {
483             lg2::error("Sensor name: {NAME}, reading error!", "NAME", name);
484             markFunctional(false);
485         }
486     }
487 
inErrorSensor488     bool inError() const
489     {
490         return errCount >= errorThreshold;
491     }
492 
updateValueSensor493     void updateValue(const double& newValue)
494     {
495         // Ignore if overriding is enabled
496         if (overriddenState)
497         {
498             return;
499         }
500 
501         if (!readingStateGood())
502         {
503             markAvailable(false);
504             for (auto& threshold : thresholds)
505             {
506                 assertThresholds(this, value, threshold.level,
507                                  threshold.direction, false);
508             }
509             updateValueProperty(std::numeric_limits<double>::quiet_NaN());
510             return;
511         }
512 
513         updateValueProperty(newValue);
514         updateInstrumentation(newValue);
515 
516         // Always check thresholds after changing the value,
517         // as the test against hysteresisTrigger now takes place in
518         // the thresholds::checkThresholds() method,
519         // which is called by checkThresholds() below,
520         // in all current implementations of sensors that have thresholds.
521         checkThresholds();
522         if (!std::isnan(newValue))
523         {
524             markFunctional(true);
525             markAvailable(true);
526         }
527     }
528 
updatePropertySensor529     void updateProperty(
530         std::shared_ptr<sdbusplus::asio::dbus_interface>& interface,
531         double& oldValue, const double& newValue,
532         const char* dbusPropertyName) const
533     {
534         if (requiresUpdate(oldValue, newValue))
535         {
536             oldValue = newValue;
537             if (interface &&
538                 !(interface->set_property(dbusPropertyName, newValue)))
539             {
540                 lg2::error("error setting property '{NAME}' to '{VALUE}'",
541                            "NAME", dbusPropertyName, "VALUE", newValue);
542             }
543         }
544     }
545 
requiresUpdateSensor546     bool requiresUpdate(const double& lVal, const double& rVal) const
547     {
548         const auto lNan = std::isnan(lVal);
549         const auto rNan = std::isnan(rVal);
550         if (lNan || rNan)
551         {
552             return (lNan != rNan);
553         }
554         return std::abs(lVal - rVal) > hysteresisPublish;
555     }
556 
557   private:
558     // If one of the thresholds for a dbus interface is provided
559     // we have to set the other one as dbus properties are never
560     // optional.
fillMissingThresholdsSensor561     void fillMissingThresholds()
562     {
563         const std::size_t thresholdsLen = thresholds.size();
564         for (std::size_t index = 0; index < thresholdsLen; ++index)
565         {
566             const thresholds::Threshold& thisThreshold = thresholds[index];
567             bool foundOpposite = false;
568             thresholds::Direction opposite = thresholds::Direction::HIGH;
569             if (thisThreshold.direction == thresholds::Direction::HIGH)
570             {
571                 opposite = thresholds::Direction::LOW;
572             }
573             for (thresholds::Threshold& otherThreshold : thresholds)
574             {
575                 if (thisThreshold.level != otherThreshold.level)
576                 {
577                     continue;
578                 }
579                 if (otherThreshold.direction != opposite)
580                 {
581                     continue;
582                 }
583                 foundOpposite = true;
584                 break;
585             }
586             if (foundOpposite)
587             {
588                 continue;
589             }
590             thresholds.emplace_back(thisThreshold.level, opposite,
591                                     std::numeric_limits<double>::quiet_NaN());
592         }
593     }
594 
updateValuePropertySensor595     void updateValueProperty(const double& newValue)
596     {
597         // Indicate that it is internal set call, not an external overwrite
598         internalSet = true;
599         updateProperty(sensorInterface, value, newValue, "Value");
600         internalSet = false;
601     }
602 };
603