1 /*
2 // Copyright (c) 2018 Intel 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 */
16 #include "dbusconfiguration.hpp"
17
18 #include "conf.hpp"
19 #include "dbushelper.hpp"
20 #include "dbusutil.hpp"
21 #include "util.hpp"
22
23 #include <boost/asio/steady_timer.hpp>
24 #include <sdbusplus/bus.hpp>
25 #include <sdbusplus/bus/match.hpp>
26 #include <sdbusplus/exception.hpp>
27
28 #include <algorithm>
29 #include <chrono>
30 #include <functional>
31 #include <iostream>
32 #include <list>
33 #include <set>
34 #include <unordered_map>
35 #include <variant>
36
37 namespace pid_control
38 {
39
40 constexpr const char* pidConfigurationInterface =
41 "xyz.openbmc_project.Configuration.Pid";
42 constexpr const char* objectManagerInterface =
43 "org.freedesktop.DBus.ObjectManager";
44 constexpr const char* pidZoneConfigurationInterface =
45 "xyz.openbmc_project.Configuration.Pid.Zone";
46 constexpr const char* stepwiseConfigurationInterface =
47 "xyz.openbmc_project.Configuration.Stepwise";
48 constexpr const char* thermalControlIface =
49 "xyz.openbmc_project.Control.ThermalMode";
50 constexpr const char* sensorInterface = "xyz.openbmc_project.Sensor.Value";
51 constexpr const char* defaultPwmInterface =
52 "xyz.openbmc_project.Control.FanPwm";
53
54 using Association = std::tuple<std::string, std::string, std::string>;
55 using Associations = std::vector<Association>;
56
57 namespace thresholds
58 {
59 constexpr const char* warningInterface =
60 "xyz.openbmc_project.Sensor.Threshold.Warning";
61 constexpr const char* criticalInterface =
62 "xyz.openbmc_project.Sensor.Threshold.Critical";
63 const std::array<const char*, 4> types = {"CriticalLow", "CriticalHigh",
64 "WarningLow", "WarningHigh"};
65
66 } // namespace thresholds
67
68 namespace dbus_configuration
69 {
70 using SensorInterfaceType = std::pair<std::string, std::string>;
71
getSensorNameFromPath(const std::string & dbusPath)72 inline std::string getSensorNameFromPath(const std::string& dbusPath)
73 {
74 return dbusPath.substr(dbusPath.find_last_of("/") + 1);
75 }
76
sensorNameToDbusName(const std::string & sensorName)77 inline std::string sensorNameToDbusName(const std::string& sensorName)
78 {
79 std::string retString = sensorName;
80 std::replace(retString.begin(), retString.end(), ' ', '_');
81 return retString;
82 }
83
getSelectedProfiles(sdbusplus::bus_t & bus)84 std::vector<std::string> getSelectedProfiles(sdbusplus::bus_t& bus)
85 {
86 std::vector<std::string> ret;
87 auto mapper =
88 bus.new_method_call("xyz.openbmc_project.ObjectMapper",
89 "/xyz/openbmc_project/object_mapper",
90 "xyz.openbmc_project.ObjectMapper", "GetSubTree");
91 mapper.append("/", 0, std::array<const char*, 1>{thermalControlIface});
92 std::unordered_map<
93 std::string, std::unordered_map<std::string, std::vector<std::string>>>
94 respData;
95
96 try
97 {
98 auto resp = bus.call(mapper);
99 resp.read(respData);
100 }
101 catch (const sdbusplus::exception_t&)
102 {
103 // can't do anything without mapper call data
104 throw std::runtime_error("ObjectMapper Call Failure");
105 }
106 if (respData.empty())
107 {
108 // if the user has profiles but doesn't expose the interface to select
109 // one, just go ahead without using profiles
110 return ret;
111 }
112
113 // assumption is that we should only have a small handful of selected
114 // profiles at a time (probably only 1), so calling each individually should
115 // not incur a large cost
116 for (const auto& objectPair : respData)
117 {
118 const std::string& path = objectPair.first;
119 for (const auto& ownerPair : objectPair.second)
120 {
121 const std::string& busName = ownerPair.first;
122 auto getProfile =
123 bus.new_method_call(busName.c_str(), path.c_str(),
124 "org.freedesktop.DBus.Properties", "Get");
125 getProfile.append(thermalControlIface, "Current");
126 std::variant<std::string> variantResp;
127 try
128 {
129 auto resp = bus.call(getProfile);
130 resp.read(variantResp);
131 }
132 catch (const sdbusplus::exception_t&)
133 {
134 throw std::runtime_error("Failure getting profile");
135 }
136 std::string mode = std::get<std::string>(variantResp);
137 ret.emplace_back(std::move(mode));
138 }
139 }
140 if constexpr (pid_control::conf::DEBUG)
141 {
142 std::cout << "Profiles selected: ";
143 for (const auto& profile : ret)
144 {
145 std::cout << profile << " ";
146 }
147 std::cout << "\n";
148 }
149 return ret;
150 }
151
eventHandler(sd_bus_message * m,void * context,sd_bus_error *)152 int eventHandler(sd_bus_message* m, void* context, sd_bus_error*)
153 {
154 if (context == nullptr || m == nullptr)
155 {
156 throw std::runtime_error("Invalid match");
157 }
158
159 // we skip associations because the mapper populates these, not the sensors
160 const std::array<const char*, 2> skipList = {
161 "xyz.openbmc_project.Association",
162 "xyz.openbmc_project.Association.Definitions"};
163
164 sdbusplus::message_t message(m);
165 if (std::string(message.get_member()) == "InterfacesAdded")
166 {
167 sdbusplus::message::object_path path;
168 std::unordered_map<
169 std::string,
170 std::unordered_map<std::string, std::variant<Associations, bool>>>
171 data;
172
173 message.read(path, data);
174
175 for (const char* skip : skipList)
176 {
177 auto find = data.find(skip);
178 if (find != data.end())
179 {
180 data.erase(find);
181 if (data.empty())
182 {
183 return 1;
184 }
185 }
186 }
187
188 if constexpr (pid_control::conf::DEBUG)
189 {
190 std::cout << "New config detected: " << path.str << std::endl;
191 for (auto& d : data)
192 {
193 std::cout << "\tdata is " << d.first << std::endl;
194 for (auto& second : d.second)
195 {
196 std::cout << "\t\tdata is " << second.first << std::endl;
197 }
198 }
199 }
200 }
201
202 boost::asio::steady_timer* timer =
203 static_cast<boost::asio::steady_timer*>(context);
204
205 // do a brief sleep as we tend to get a bunch of these events at
206 // once
207 timer->expires_after(std::chrono::seconds(2));
208 timer->async_wait([](const boost::system::error_code ec) {
209 if (ec == boost::asio::error::operation_aborted)
210 {
211 /* another timer started*/
212 return;
213 }
214
215 std::cout << "New configuration detected, reloading\n.";
216 tryRestartControlLoops();
217 });
218
219 return 1;
220 }
221
createMatches(sdbusplus::bus_t & bus,boost::asio::steady_timer & timer)222 void createMatches(sdbusplus::bus_t& bus, boost::asio::steady_timer& timer)
223 {
224 // this is a list because the matches can't be moved
225 static std::list<sdbusplus::bus::match_t> matches;
226
227 const std::array<std::string, 4> interfaces = {
228 thermalControlIface, pidConfigurationInterface,
229 pidZoneConfigurationInterface, stepwiseConfigurationInterface};
230
231 // this list only needs to be created once
232 if (!matches.empty())
233 {
234 return;
235 }
236
237 // we restart when the configuration changes or there are new sensors
238 for (const auto& interface : interfaces)
239 {
240 matches.emplace_back(
241 bus,
242 "type='signal',member='PropertiesChanged',arg0namespace='" +
243 interface + "'",
244 eventHandler, &timer);
245 }
246 matches.emplace_back(
247 bus,
248 "type='signal',member='InterfacesAdded',arg0path='/xyz/openbmc_project/"
249 "sensors/'",
250 eventHandler, &timer);
251 matches.emplace_back(bus,
252 "type='signal',member='InterfacesRemoved',arg0path='/"
253 "xyz/openbmc_project/sensors/'",
254 eventHandler, &timer);
255 }
256
257 /**
258 * retrieve an attribute from the pid configuration map
259 * @param[in] base - the PID configuration map, keys are the attributes and
260 * value is the variant associated with that attribute.
261 * @param attributeName - the name of the attribute
262 * @return a variant holding the value associated with a key
263 * @throw runtime_error : attributeName is not in base
264 */
getPIDAttribute(const std::unordered_map<std::string,DbusVariantType> & base,const std::string & attributeName)265 inline DbusVariantType getPIDAttribute(
266 const std::unordered_map<std::string, DbusVariantType>& base,
267 const std::string& attributeName)
268 {
269 auto search = base.find(attributeName);
270 if (search == base.end())
271 {
272 throw std::runtime_error("missing attribute " + attributeName);
273 }
274 return search->second;
275 }
276
getCycleTimeSetting(const std::unordered_map<std::string,DbusVariantType> & zone,const int zoneIndex,const std::string & attributeName,uint64_t & value)277 inline void getCycleTimeSetting(
278 const std::unordered_map<std::string, DbusVariantType>& zone,
279 const int zoneIndex, const std::string& attributeName, uint64_t& value)
280 {
281 auto findAttributeName = zone.find(attributeName);
282 if (findAttributeName != zone.end())
283 {
284 double tmpAttributeValue =
285 std::visit(VariantToDoubleVisitor(), zone.at(attributeName));
286 if (tmpAttributeValue >= 1.0)
287 {
288 value = static_cast<uint64_t>(tmpAttributeValue);
289 }
290 else
291 {
292 std::cerr << "Zone " << zoneIndex << ": " << attributeName
293 << " is invalid. Use default " << value << " ms\n";
294 }
295 }
296 else
297 {
298 std::cerr << "Zone " << zoneIndex << ": " << attributeName
299 << " cannot find setting. Use default " << value << " ms\n";
300 }
301 }
302
populatePidInfo(sdbusplus::bus_t & bus,const std::unordered_map<std::string,DbusVariantType> & base,conf::ControllerInfo & info,const std::string * thresholdProperty,const std::map<std::string,conf::SensorConfig> & sensorConfig)303 void populatePidInfo(
304 [[maybe_unused]] sdbusplus::bus_t& bus,
305 const std::unordered_map<std::string, DbusVariantType>& base,
306 conf::ControllerInfo& info, const std::string* thresholdProperty,
307 const std::map<std::string, conf::SensorConfig>& sensorConfig)
308 {
309 info.type = std::get<std::string>(getPIDAttribute(base, "Class"));
310 if (info.type == "fan")
311 {
312 info.setpoint = 0;
313 }
314 else
315 {
316 info.setpoint = std::visit(VariantToDoubleVisitor(),
317 getPIDAttribute(base, "SetPoint"));
318 }
319
320 int failsafepercent = 0;
321 auto findFailSafe = base.find("FailSafePercent");
322 if (findFailSafe != base.end())
323 {
324 failsafepercent = std::visit(VariantToDoubleVisitor(),
325 getPIDAttribute(base, "FailSafePercent"));
326 }
327 info.failSafePercent = failsafepercent;
328
329 if (thresholdProperty != nullptr)
330 {
331 std::string interface;
332 if (*thresholdProperty == "WarningHigh" ||
333 *thresholdProperty == "WarningLow")
334 {
335 interface = thresholds::warningInterface;
336 }
337 else
338 {
339 interface = thresholds::criticalInterface;
340 }
341
342 // Although this checks only the first vector element for the
343 // named threshold, it is OK, because the SetPointOffset parser
344 // splits up the input into individual vectors, each with only a
345 // single element, if it detects that SetPointOffset is in use.
346 const std::string& path =
347 sensorConfig.at(info.inputs.front().name).readPath;
348
349 DbusHelper helper(sdbusplus::bus::new_system());
350 std::string service = helper.getService(interface, path);
351 double reading = 0;
352 try
353 {
354 helper.getProperty(service, path, interface, *thresholdProperty,
355 reading);
356 }
357 catch (const sdbusplus::exception_t& ex)
358 {
359 // unsupported threshold, leaving reading at 0
360 }
361
362 info.setpoint += reading;
363 }
364
365 info.pidInfo.ts = 1.0; // currently unused
366 info.pidInfo.proportionalCoeff = std::visit(
367 VariantToDoubleVisitor(), getPIDAttribute(base, "PCoefficient"));
368 info.pidInfo.integralCoeff = std::visit(
369 VariantToDoubleVisitor(), getPIDAttribute(base, "ICoefficient"));
370 // DCoefficient is below, it is optional, same reason as in buildjson.cpp
371 info.pidInfo.feedFwdOffset = std::visit(
372 VariantToDoubleVisitor(), getPIDAttribute(base, "FFOffCoefficient"));
373 info.pidInfo.feedFwdGain = std::visit(
374 VariantToDoubleVisitor(), getPIDAttribute(base, "FFGainCoefficient"));
375 info.pidInfo.integralLimit.max = std::visit(
376 VariantToDoubleVisitor(), getPIDAttribute(base, "ILimitMax"));
377 info.pidInfo.integralLimit.min = std::visit(
378 VariantToDoubleVisitor(), getPIDAttribute(base, "ILimitMin"));
379 info.pidInfo.outLim.max = std::visit(VariantToDoubleVisitor(),
380 getPIDAttribute(base, "OutLimitMax"));
381 info.pidInfo.outLim.min = std::visit(VariantToDoubleVisitor(),
382 getPIDAttribute(base, "OutLimitMin"));
383 info.pidInfo.slewNeg =
384 std::visit(VariantToDoubleVisitor(), getPIDAttribute(base, "SlewNeg"));
385 info.pidInfo.slewPos =
386 std::visit(VariantToDoubleVisitor(), getPIDAttribute(base, "SlewPos"));
387
388 bool checkHysterWithSetpt = false;
389 double negativeHysteresis = 0;
390 double positiveHysteresis = 0;
391 double derivativeCoeff = 0;
392
393 auto findCheckHysterFlag = base.find("CheckHysteresisWithSetpoint");
394 auto findNeg = base.find("NegativeHysteresis");
395 auto findPos = base.find("PositiveHysteresis");
396 auto findDerivative = base.find("DCoefficient");
397
398 if (findCheckHysterFlag != base.end())
399 {
400 checkHysterWithSetpt = std::get<bool>(findCheckHysterFlag->second);
401 }
402 if (findNeg != base.end())
403 {
404 negativeHysteresis =
405 std::visit(VariantToDoubleVisitor(), findNeg->second);
406 }
407 if (findPos != base.end())
408 {
409 positiveHysteresis =
410 std::visit(VariantToDoubleVisitor(), findPos->second);
411 }
412 if (findDerivative != base.end())
413 {
414 derivativeCoeff =
415 std::visit(VariantToDoubleVisitor(), findDerivative->second);
416 }
417
418 info.pidInfo.checkHysterWithSetpt = checkHysterWithSetpt;
419 info.pidInfo.negativeHysteresis = negativeHysteresis;
420 info.pidInfo.positiveHysteresis = positiveHysteresis;
421 info.pidInfo.derivativeCoeff = derivativeCoeff;
422 }
423
init(sdbusplus::bus_t & bus,boost::asio::steady_timer & timer,std::map<std::string,conf::SensorConfig> & sensorConfig,std::map<int64_t,conf::PIDConf> & zoneConfig,std::map<int64_t,conf::ZoneConfig> & zoneDetailsConfig)424 bool init(sdbusplus::bus_t& bus, boost::asio::steady_timer& timer,
425 std::map<std::string, conf::SensorConfig>& sensorConfig,
426 std::map<int64_t, conf::PIDConf>& zoneConfig,
427 std::map<int64_t, conf::ZoneConfig>& zoneDetailsConfig)
428 {
429 sensorConfig.clear();
430 zoneConfig.clear();
431 zoneDetailsConfig.clear();
432
433 createMatches(bus, timer);
434
435 auto mapper =
436 bus.new_method_call("xyz.openbmc_project.ObjectMapper",
437 "/xyz/openbmc_project/object_mapper",
438 "xyz.openbmc_project.ObjectMapper", "GetSubTree");
439 mapper.append(
440 "/", 0,
441 std::array<const char*, 6>{
442 objectManagerInterface, pidConfigurationInterface,
443 pidZoneConfigurationInterface, stepwiseConfigurationInterface,
444 sensorInterface, defaultPwmInterface});
445 std::unordered_map<
446 std::string, std::unordered_map<std::string, std::vector<std::string>>>
447 respData;
448 try
449 {
450 auto resp = bus.call(mapper);
451 resp.read(respData);
452 }
453 catch (const sdbusplus::exception_t&)
454 {
455 // can't do anything without mapper call data
456 throw std::runtime_error("ObjectMapper Call Failure");
457 }
458
459 if (respData.empty())
460 {
461 // can't do anything without mapper call data
462 throw std::runtime_error("No configuration data available from Mapper");
463 }
464 // create a map of pair of <has pid configuration, ObjectManager path>
465 std::unordered_map<std::string, std::pair<bool, std::string>> owners;
466 // and a map of <path, interface> for sensors
467 std::unordered_map<std::string, std::string> sensors;
468 for (const auto& objectPair : respData)
469 {
470 for (const auto& ownerPair : objectPair.second)
471 {
472 auto& owner = owners[ownerPair.first];
473 for (const std::string& interface : ownerPair.second)
474 {
475 if (interface == objectManagerInterface)
476 {
477 owner.second = objectPair.first;
478 }
479 if (interface == pidConfigurationInterface ||
480 interface == pidZoneConfigurationInterface ||
481 interface == stepwiseConfigurationInterface)
482 {
483 owner.first = true;
484 }
485 if (interface == sensorInterface ||
486 interface == defaultPwmInterface)
487 {
488 // we're not interested in pwm sensors, just pwm control
489 if (interface == sensorInterface &&
490 objectPair.first.find("pwm") != std::string::npos)
491 {
492 continue;
493 }
494 sensors[objectPair.first] = interface;
495 }
496 }
497 }
498 }
499 ManagedObjectType configurations;
500 for (const auto& owner : owners)
501 {
502 // skip if no pid configuration (means probably a sensor)
503 if (!owner.second.first)
504 {
505 continue;
506 }
507 auto endpoint = bus.new_method_call(
508 owner.first.c_str(), owner.second.second.c_str(),
509 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
510 ManagedObjectType configuration;
511 try
512 {
513 auto responce = bus.call(endpoint);
514 responce.read(configuration);
515 }
516 catch (const sdbusplus::exception_t&)
517 {
518 // this shouldn't happen, probably means daemon crashed
519 throw std::runtime_error(
520 "Error getting managed objects from " + owner.first);
521 }
522
523 for (auto& pathPair : configuration)
524 {
525 if (pathPair.second.find(pidConfigurationInterface) !=
526 pathPair.second.end() ||
527 pathPair.second.find(pidZoneConfigurationInterface) !=
528 pathPair.second.end() ||
529 pathPair.second.find(stepwiseConfigurationInterface) !=
530 pathPair.second.end())
531 {
532 configurations.emplace(pathPair);
533 }
534 }
535 }
536
537 // remove controllers from config that aren't in the current profile(s)
538 std::vector<std::string> selectedProfiles = getSelectedProfiles(bus);
539 if (selectedProfiles.size())
540 {
541 for (auto pathIt = configurations.begin();
542 pathIt != configurations.end();)
543 {
544 for (auto confIt = pathIt->second.begin();
545 confIt != pathIt->second.end();)
546 {
547 auto profilesFind = confIt->second.find("Profiles");
548 if (profilesFind == confIt->second.end())
549 {
550 confIt++;
551 continue; // if no profiles selected, apply always
552 }
553 auto profiles =
554 std::get<std::vector<std::string>>(profilesFind->second);
555 if (profiles.empty())
556 {
557 confIt++;
558 continue;
559 }
560
561 bool found = false;
562 for (const std::string& profile : profiles)
563 {
564 if (std::find(selectedProfiles.begin(),
565 selectedProfiles.end(), profile) !=
566 selectedProfiles.end())
567 {
568 found = true;
569 break;
570 }
571 }
572 if (found)
573 {
574 confIt++;
575 }
576 else
577 {
578 confIt = pathIt->second.erase(confIt);
579 }
580 }
581 if (pathIt->second.empty())
582 {
583 pathIt = configurations.erase(pathIt);
584 }
585 else
586 {
587 pathIt++;
588 }
589 }
590 }
591
592 // On D-Bus, although not necessary,
593 // having the "zoneID" field can still be useful,
594 // as it is used for diagnostic messages,
595 // logging file names, and so on.
596 // Accept optional "ZoneIndex" parameter to explicitly specify.
597 // If not present, or not unique, auto-assign index,
598 // using 0-based numbering, ensuring uniqueness.
599 std::map<std::string, int64_t> foundZones;
600 for (const auto& configuration : configurations)
601 {
602 auto findZone =
603 configuration.second.find(pidZoneConfigurationInterface);
604 if (findZone != configuration.second.end())
605 {
606 const auto& zone = findZone->second;
607
608 const std::string& name = std::get<std::string>(zone.at("Name"));
609
610 auto findZoneIndex = zone.find("ZoneIndex");
611 if (findZoneIndex == zone.end())
612 {
613 continue;
614 }
615
616 auto ptrZoneIndex = std::get_if<double>(&(findZoneIndex->second));
617 if (!ptrZoneIndex)
618 {
619 continue;
620 }
621
622 auto desiredIndex = static_cast<int64_t>(*ptrZoneIndex);
623 auto grantedIndex = setZoneIndex(name, foundZones, desiredIndex);
624 std::cout << "Zone " << name << " is at ZoneIndex " << grantedIndex
625 << "\n";
626 }
627 }
628
629 for (const auto& configuration : configurations)
630 {
631 auto findZone =
632 configuration.second.find(pidZoneConfigurationInterface);
633 if (findZone != configuration.second.end())
634 {
635 const auto& zone = findZone->second;
636
637 const std::string& name = std::get<std::string>(zone.at("Name"));
638
639 auto index = getZoneIndex(name, foundZones);
640
641 auto& details = zoneDetailsConfig[index];
642
643 details.minThermalOutput = std::visit(VariantToDoubleVisitor(),
644 zone.at("MinThermalOutput"));
645
646 int failsafepercent = 0;
647 auto findFailSafe = zone.find("FailSafePercent");
648 if (findFailSafe != zone.end())
649 {
650 failsafepercent = std::visit(VariantToDoubleVisitor(),
651 zone.at("FailSafePercent"));
652 }
653 details.failsafePercent = failsafepercent;
654
655 getCycleTimeSetting(zone, index, "CycleIntervalTimeMS",
656 details.cycleTime.cycleIntervalTimeMS);
657 getCycleTimeSetting(zone, index, "UpdateThermalsTimeMS",
658 details.cycleTime.updateThermalsTimeMS);
659
660 bool accumulateSetPoint = false;
661 auto findAccSetPoint = zone.find("AccumulateSetPoint");
662 if (findAccSetPoint != zone.end())
663 {
664 accumulateSetPoint = std::get<bool>(findAccSetPoint->second);
665 }
666 details.accumulateSetPoint = accumulateSetPoint;
667 }
668 auto findBase = configuration.second.find(pidConfigurationInterface);
669 // loop through all the PID configurations and fill out a sensor config
670 if (findBase != configuration.second.end())
671 {
672 const auto& base =
673 configuration.second.at(pidConfigurationInterface);
674 const std::string pidName =
675 sensorNameToDbusName(std::get<std::string>(base.at("Name")));
676 const std::string pidClass =
677 std::get<std::string>(base.at("Class"));
678 const std::vector<std::string>& zones =
679 std::get<std::vector<std::string>>(base.at("Zones"));
680 for (const std::string& zone : zones)
681 {
682 auto index = getZoneIndex(zone, foundZones);
683
684 conf::PIDConf& conf = zoneConfig[index];
685 std::vector<std::string> inputSensorNames(
686 std::get<std::vector<std::string>>(base.at("Inputs")));
687 std::vector<std::string> outputSensorNames;
688 std::vector<std::string> missingAcceptableSensorNames;
689
690 auto findMissingAcceptable = base.find("MissingIsAcceptable");
691 if (findMissingAcceptable != base.end())
692 {
693 missingAcceptableSensorNames =
694 std::get<std::vector<std::string>>(
695 findMissingAcceptable->second);
696 }
697
698 // assumption: all fan pids must have at least one output
699 if (pidClass == "fan")
700 {
701 outputSensorNames = std::get<std::vector<std::string>>(
702 getPIDAttribute(base, "Outputs"));
703 }
704
705 bool unavailableAsFailed = true;
706 auto findUnavailableAsFailed =
707 base.find("InputUnavailableAsFailed");
708 if (findUnavailableAsFailed != base.end())
709 {
710 unavailableAsFailed =
711 std::get<bool>(findUnavailableAsFailed->second);
712 }
713
714 std::vector<SensorInterfaceType> inputSensorInterfaces;
715 std::vector<SensorInterfaceType> outputSensorInterfaces;
716 std::vector<SensorInterfaceType>
717 missingAcceptableSensorInterfaces;
718
719 /* populate an interface list for different sensor direction
720 * types (input,output)
721 */
722 /* take the Inputs from the configuration and generate
723 * a list of dbus descriptors (path, interface).
724 * Mapping can be many-to-one since an element of Inputs can be
725 * a regex
726 */
727 for (const std::string& sensorName : inputSensorNames)
728 {
729 findSensors(sensors, sensorNameToDbusName(sensorName),
730 inputSensorInterfaces);
731 }
732 for (const std::string& sensorName : outputSensorNames)
733 {
734 findSensors(sensors, sensorNameToDbusName(sensorName),
735 outputSensorInterfaces);
736 }
737 for (const std::string& sensorName :
738 missingAcceptableSensorNames)
739 {
740 findSensors(sensors, sensorNameToDbusName(sensorName),
741 missingAcceptableSensorInterfaces);
742 }
743
744 inputSensorNames.clear();
745 for (const SensorInterfaceType& inputSensorInterface :
746 inputSensorInterfaces)
747 {
748 const std::string& dbusInterface =
749 inputSensorInterface.second;
750 const std::string& inputSensorPath =
751 inputSensorInterface.first;
752
753 // Setting timeout to 0 is intentional, as D-Bus passive
754 // sensor updates are pushed in, not pulled by timer poll.
755 // Setting ignoreDbusMinMax is intentional, as this
756 // prevents normalization of values to [0.0, 1.0] range,
757 // which would mess up the PID loop math.
758 // All non-fan PID classes should be initialized this way.
759 // As for why a fan should not use this code path, see
760 // the ed1dafdf168def37c65bfb7a5efd18d9dbe04727 commit.
761 if ((pidClass == "temp") || (pidClass == "margin") ||
762 (pidClass == "power") || (pidClass == "powersum"))
763 {
764 std::string inputSensorName =
765 getSensorNameFromPath(inputSensorPath);
766 auto& config = sensorConfig[inputSensorName];
767 inputSensorNames.push_back(inputSensorName);
768 config.type = pidClass;
769 config.readPath = inputSensorInterface.first;
770 config.timeout = 0;
771 config.ignoreDbusMinMax = true;
772 config.unavailableAsFailed = unavailableAsFailed;
773 }
774
775 if (dbusInterface != sensorInterface)
776 {
777 /* all expected inputs in the configuration are expected
778 * to be sensor interfaces
779 */
780 throw std::runtime_error(
781 "sensor at dbus path [" + inputSensorPath +
782 "] has an interface [" + dbusInterface +
783 "] that does not match the expected interface of " +
784 sensorInterface);
785 }
786 }
787
788 // MissingIsAcceptable same postprocessing as Inputs
789 missingAcceptableSensorNames.clear();
790 for (const SensorInterfaceType&
791 missingAcceptableSensorInterface :
792 missingAcceptableSensorInterfaces)
793 {
794 const std::string& dbusInterface =
795 missingAcceptableSensorInterface.second;
796 const std::string& missingAcceptableSensorPath =
797 missingAcceptableSensorInterface.first;
798
799 std::string missingAcceptableSensorName =
800 getSensorNameFromPath(missingAcceptableSensorPath);
801 missingAcceptableSensorNames.push_back(
802 missingAcceptableSensorName);
803
804 if (dbusInterface != sensorInterface)
805 {
806 /* MissingIsAcceptable same error checking as Inputs
807 */
808 throw std::runtime_error(
809 "sensor at dbus path [" +
810 missingAcceptableSensorPath +
811 "] has an interface [" + dbusInterface +
812 "] that does not match the expected interface of " +
813 sensorInterface);
814 }
815 }
816
817 /* fan pids need to pair up tach sensors with their pwm
818 * counterparts
819 */
820 if (pidClass == "fan")
821 {
822 /* If a PID is a fan there should be either
823 * (1) one output(pwm) per input(tach)
824 * OR
825 * (2) one putput(pwm) for all inputs(tach)
826 * everything else indicates a bad configuration.
827 */
828 bool singlePwm = false;
829 if (outputSensorInterfaces.size() == 1)
830 {
831 /* one pwm, set write paths for all fan sensors to it */
832 singlePwm = true;
833 }
834 else if (inputSensorInterfaces.size() ==
835 outputSensorInterfaces.size())
836 {
837 /* one to one mapping, each fan sensor gets its own pwm
838 * control */
839 singlePwm = false;
840 }
841 else
842 {
843 throw std::runtime_error(
844 "fan PID has invalid number of Outputs");
845 }
846 std::string fanSensorName;
847 std::string pwmPath;
848 std::string pwmInterface;
849 std::string pwmSensorName;
850 if (singlePwm)
851 {
852 /* if just a single output(pwm) is provided then use
853 * that pwm control path for all the fan sensor write
854 * path configs
855 */
856 pwmPath = outputSensorInterfaces.at(0).first;
857 pwmInterface = outputSensorInterfaces.at(0).second;
858 }
859 for (uint32_t idx = 0; idx < inputSensorInterfaces.size();
860 idx++)
861 {
862 if (!singlePwm)
863 {
864 pwmPath = outputSensorInterfaces.at(idx).first;
865 pwmInterface =
866 outputSensorInterfaces.at(idx).second;
867 }
868 if (defaultPwmInterface != pwmInterface)
869 {
870 throw std::runtime_error(
871 "fan pwm control at dbus path [" + pwmPath +
872 "] has an interface [" + pwmInterface +
873 "] that does not match the expected interface "
874 "of " +
875 defaultPwmInterface);
876 }
877 const std::string& fanPath =
878 inputSensorInterfaces.at(idx).first;
879 fanSensorName = getSensorNameFromPath(fanPath);
880 pwmSensorName = getSensorNameFromPath(pwmPath);
881 std::string fanPwmIndex = fanSensorName + pwmSensorName;
882 inputSensorNames.push_back(fanPwmIndex);
883 auto& fanConfig = sensorConfig[fanPwmIndex];
884 fanConfig.type = pidClass;
885 fanConfig.readPath = fanPath;
886 fanConfig.writePath = pwmPath;
887 // todo: un-hardcode this if there are fans with
888 // different ranges
889 fanConfig.max = 255;
890 fanConfig.min = 0;
891 }
892 }
893 // if the sensors aren't available in the current state, don't
894 // add them to the configuration.
895 if (inputSensorNames.empty())
896 {
897 continue;
898 }
899
900 std::string offsetType;
901
902 // SetPointOffset is a threshold value to pull from the sensor
903 // to apply an offset. For upper thresholds this means the
904 // setpoint is usually negative.
905 auto findSetpointOffset = base.find("SetPointOffset");
906 if (findSetpointOffset != base.end())
907 {
908 offsetType =
909 std::get<std::string>(findSetpointOffset->second);
910 if (std::find(thresholds::types.begin(),
911 thresholds::types.end(), offsetType) ==
912 thresholds::types.end())
913 {
914 throw std::runtime_error(
915 "Unsupported type: " + offsetType);
916 }
917 }
918
919 std::vector<double> inputTempToMargin;
920
921 auto findTempToMargin = base.find("TempToMargin");
922 if (findTempToMargin != base.end())
923 {
924 inputTempToMargin =
925 std::get<std::vector<double>>(findTempToMargin->second);
926 }
927
928 std::vector<pid_control::conf::SensorInput> sensorInputs =
929 spliceInputs(inputSensorNames, inputTempToMargin,
930 missingAcceptableSensorNames);
931
932 if (offsetType.empty())
933 {
934 conf::ControllerInfo& info = conf[pidName];
935 info.inputs = std::move(sensorInputs);
936 populatePidInfo(bus, base, info, nullptr, sensorConfig);
937 }
938 else
939 {
940 // we have to split up the inputs, as in practice t-control
941 // values will differ, making setpoints differ
942 for (const pid_control::conf::SensorInput& input :
943 sensorInputs)
944 {
945 conf::ControllerInfo& info = conf[input.name];
946 info.inputs.emplace_back(input);
947 populatePidInfo(bus, base, info, &offsetType,
948 sensorConfig);
949 }
950 }
951 }
952 }
953 auto findStepwise =
954 configuration.second.find(stepwiseConfigurationInterface);
955 if (findStepwise != configuration.second.end())
956 {
957 const auto& base = findStepwise->second;
958 const std::string pidName =
959 sensorNameToDbusName(std::get<std::string>(base.at("Name")));
960 const std::vector<std::string>& zones =
961 std::get<std::vector<std::string>>(base.at("Zones"));
962 for (const std::string& zone : zones)
963 {
964 auto index = getZoneIndex(zone, foundZones);
965
966 conf::PIDConf& conf = zoneConfig[index];
967
968 std::vector<std::string> inputs;
969 std::vector<std::string> missingAcceptableSensors;
970 std::vector<std::string> missingAcceptableSensorNames;
971 std::vector<std::string> sensorNames =
972 std::get<std::vector<std::string>>(base.at("Inputs"));
973
974 auto findMissingAcceptable = base.find("MissingIsAcceptable");
975 if (findMissingAcceptable != base.end())
976 {
977 missingAcceptableSensorNames =
978 std::get<std::vector<std::string>>(
979 findMissingAcceptable->second);
980 }
981
982 bool unavailableAsFailed = true;
983 auto findUnavailableAsFailed =
984 base.find("InputUnavailableAsFailed");
985 if (findUnavailableAsFailed != base.end())
986 {
987 unavailableAsFailed =
988 std::get<bool>(findUnavailableAsFailed->second);
989 }
990
991 bool sensorFound = false;
992 for (const std::string& sensorName : sensorNames)
993 {
994 std::vector<std::pair<std::string, std::string>>
995 sensorPathIfacePairs;
996 if (!findSensors(sensors, sensorNameToDbusName(sensorName),
997 sensorPathIfacePairs))
998 {
999 break;
1000 }
1001
1002 for (const auto& sensorPathIfacePair : sensorPathIfacePairs)
1003 {
1004 std::string shortName =
1005 getSensorNameFromPath(sensorPathIfacePair.first);
1006
1007 inputs.push_back(shortName);
1008 auto& config = sensorConfig[shortName];
1009 config.readPath = sensorPathIfacePair.first;
1010 config.type = "temp";
1011 config.ignoreDbusMinMax = true;
1012 config.unavailableAsFailed = unavailableAsFailed;
1013 // todo: maybe un-hardcode this if we run into slower
1014 // timeouts with sensors
1015
1016 config.timeout = 0;
1017 sensorFound = true;
1018 }
1019 }
1020 if (!sensorFound)
1021 {
1022 continue;
1023 }
1024
1025 // MissingIsAcceptable same postprocessing as Inputs
1026 for (const std::string& missingAcceptableSensorName :
1027 missingAcceptableSensorNames)
1028 {
1029 std::vector<std::pair<std::string, std::string>>
1030 sensorPathIfacePairs;
1031 if (!findSensors(
1032 sensors,
1033 sensorNameToDbusName(missingAcceptableSensorName),
1034 sensorPathIfacePairs))
1035 {
1036 break;
1037 }
1038
1039 for (const auto& sensorPathIfacePair : sensorPathIfacePairs)
1040 {
1041 std::string shortName =
1042 getSensorNameFromPath(sensorPathIfacePair.first);
1043
1044 missingAcceptableSensors.push_back(shortName);
1045 }
1046 }
1047
1048 conf::ControllerInfo& info = conf[pidName];
1049
1050 std::vector<double> inputTempToMargin;
1051
1052 auto findTempToMargin = base.find("TempToMargin");
1053 if (findTempToMargin != base.end())
1054 {
1055 inputTempToMargin =
1056 std::get<std::vector<double>>(findTempToMargin->second);
1057 }
1058
1059 info.inputs = spliceInputs(inputs, inputTempToMargin,
1060 missingAcceptableSensors);
1061
1062 info.type = "stepwise";
1063 info.stepwiseInfo.ts = 1.0; // currently unused
1064 info.stepwiseInfo.positiveHysteresis = 0.0;
1065 info.stepwiseInfo.negativeHysteresis = 0.0;
1066 std::string subtype = std::get<std::string>(base.at("Class"));
1067
1068 info.stepwiseInfo.isCeiling = (subtype == "Ceiling");
1069 auto findPosHyst = base.find("PositiveHysteresis");
1070 auto findNegHyst = base.find("NegativeHysteresis");
1071 if (findPosHyst != base.end())
1072 {
1073 info.stepwiseInfo.positiveHysteresis = std::visit(
1074 VariantToDoubleVisitor(), findPosHyst->second);
1075 }
1076 if (findNegHyst != base.end())
1077 {
1078 info.stepwiseInfo.negativeHysteresis = std::visit(
1079 VariantToDoubleVisitor(), findNegHyst->second);
1080 }
1081 std::vector<double> readings =
1082 std::get<std::vector<double>>(base.at("Reading"));
1083 if (readings.size() > ec::maxStepwisePoints)
1084 {
1085 throw std::invalid_argument("Too many stepwise points.");
1086 }
1087 if (readings.empty())
1088 {
1089 throw std::invalid_argument(
1090 "Must have one stepwise point.");
1091 }
1092 std::copy(readings.begin(), readings.end(),
1093 info.stepwiseInfo.reading);
1094 if (readings.size() < ec::maxStepwisePoints)
1095 {
1096 info.stepwiseInfo.reading[readings.size()] =
1097 std::numeric_limits<double>::quiet_NaN();
1098 }
1099 std::vector<double> outputs =
1100 std::get<std::vector<double>>(base.at("Output"));
1101 if (readings.size() != outputs.size())
1102 {
1103 throw std::invalid_argument(
1104 "Outputs size must match readings");
1105 }
1106 std::copy(outputs.begin(), outputs.end(),
1107 info.stepwiseInfo.output);
1108 if (outputs.size() < ec::maxStepwisePoints)
1109 {
1110 info.stepwiseInfo.output[outputs.size()] =
1111 std::numeric_limits<double>::quiet_NaN();
1112 }
1113 }
1114 }
1115 }
1116 if constexpr (pid_control::conf::DEBUG)
1117 {
1118 debugPrint(sensorConfig, zoneConfig, zoneDetailsConfig);
1119 }
1120 if (zoneConfig.empty() || zoneDetailsConfig.empty())
1121 {
1122 std::cerr
1123 << "No fan zones, application pausing until new configuration\n";
1124 return false;
1125 }
1126 return true;
1127 }
1128
1129 } // namespace dbus_configuration
1130 } // namespace pid_control
1131