1 /*
2 // Copyright (c) 2019 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 
17 #include "DeviceMgmt.hpp"
18 #include "PSUEvent.hpp"
19 #include "PSUSensor.hpp"
20 #include "PwmSensor.hpp"
21 #include "SensorPaths.hpp"
22 #include "Thresholds.hpp"
23 #include "Utils.hpp"
24 #include "VariantVisitors.hpp"
25 
26 #include <boost/algorithm/string/case_conv.hpp>
27 #include <boost/algorithm/string/replace.hpp>
28 #include <boost/asio/error.hpp>
29 #include <boost/asio/io_context.hpp>
30 #include <boost/asio/post.hpp>
31 #include <boost/asio/steady_timer.hpp>
32 #include <boost/container/flat_map.hpp>
33 #include <boost/container/flat_set.hpp>
34 #include <sdbusplus/asio/connection.hpp>
35 #include <sdbusplus/asio/object_server.hpp>
36 #include <sdbusplus/bus.hpp>
37 #include <sdbusplus/bus/match.hpp>
38 #include <sdbusplus/exception.hpp>
39 #include <sdbusplus/message.hpp>
40 #include <sdbusplus/message/native_types.hpp>
41 
42 #include <algorithm>
43 #include <array>
44 #include <cctype>
45 #include <chrono>
46 #include <cmath>
47 #include <cstddef>
48 #include <cstdint>
49 #include <exception>
50 #include <filesystem>
51 #include <fstream>
52 #include <functional>
53 #include <iostream>
54 #include <memory>
55 #include <regex>
56 #include <stdexcept>
57 #include <string>
58 #include <string_view>
59 #include <utility>
60 #include <variant>
61 #include <vector>
62 
63 static constexpr bool debug = false;
64 static std::regex i2cDevRegex(R"((\/i2c\-\d+\/\d+-[a-fA-F0-9]{4,4})(\/|$))");
65 
66 static const I2CDeviceTypeMap sensorTypes{
67     {"ADC128D818", I2CDeviceType{"adc128d818", true}},
68     {"ADM1266", I2CDeviceType{"adm1266", true}},
69     {"ADM1272", I2CDeviceType{"adm1272", true}},
70     {"ADM1275", I2CDeviceType{"adm1275", true}},
71     {"ADM1278", I2CDeviceType{"adm1278", true}},
72     {"ADM1293", I2CDeviceType{"adm1293", true}},
73     {"ADS1015", I2CDeviceType{"ads1015", true}},
74     {"ADS7830", I2CDeviceType{"ads7830", true}},
75     {"AHE50DC_FAN", I2CDeviceType{"ahe50dc_fan", true}},
76     {"BMR490", I2CDeviceType{"bmr490", true}},
77     {"cffps", I2CDeviceType{"cffps", true}},
78     {"cffps1", I2CDeviceType{"cffps", true}},
79     {"cffps2", I2CDeviceType{"cffps", true}},
80     {"cffps3", I2CDeviceType{"cffps", true}},
81     {"DPS800", I2CDeviceType{"dps800", true}},
82     {"INA219", I2CDeviceType{"ina219", true}},
83     {"INA230", I2CDeviceType{"ina230", true}},
84     {"INA238", I2CDeviceType{"ina238", true}},
85     {"IPSPS1", I2CDeviceType{"ipsps1", true}},
86     {"IR38060", I2CDeviceType{"ir38060", true}},
87     {"IR38164", I2CDeviceType{"ir38164", true}},
88     {"IR38263", I2CDeviceType{"ir38263", true}},
89     {"ISL68137", I2CDeviceType{"isl68137", true}},
90     {"ISL68220", I2CDeviceType{"isl68220", true}},
91     {"ISL68223", I2CDeviceType{"isl68223", true}},
92     {"ISL69225", I2CDeviceType{"isl69225", true}},
93     {"ISL69243", I2CDeviceType{"isl69243", true}},
94     {"ISL69260", I2CDeviceType{"isl69260", true}},
95     {"LM25066", I2CDeviceType{"lm25066", true}},
96     {"LTC2945", I2CDeviceType{"ltc2945", true}},
97     {"LTC4286", I2CDeviceType{"ltc4286", true}},
98     {"LTC4287", I2CDeviceType{"ltc4287", true}},
99     {"MAX5970", I2CDeviceType{"max5970", true}},
100     {"MAX11607", I2CDeviceType{"max11607", false}},
101     {"MAX11615", I2CDeviceType{"max11615", false}},
102     {"MAX11617", I2CDeviceType{"max11617", false}},
103     {"MAX16601", I2CDeviceType{"max16601", true}},
104     {"MAX20710", I2CDeviceType{"max20710", true}},
105     {"MAX20730", I2CDeviceType{"max20730", true}},
106     {"MAX20734", I2CDeviceType{"max20734", true}},
107     {"MAX20796", I2CDeviceType{"max20796", true}},
108     {"MAX34451", I2CDeviceType{"max34451", true}},
109     {"MP2856", I2CDeviceType{"mp2856", true}},
110     {"MP2857", I2CDeviceType{"mp2857", true}},
111     {"MP2971", I2CDeviceType{"mp2971", true}},
112     {"MP2973", I2CDeviceType{"mp2973", true}},
113     {"MP2975", I2CDeviceType{"mp2975", true}},
114     {"MP5023", I2CDeviceType{"mp5023", true}},
115     {"MP5990", I2CDeviceType{"mp5990", true}},
116     {"MPQ8785", I2CDeviceType{"mpq8785", true}},
117     {"NCP4200", I2CDeviceType{"ncp4200", true}},
118     {"PLI1209BC", I2CDeviceType{"pli1209bc", true}},
119     {"pmbus", I2CDeviceType{"pmbus", true}},
120     {"PXE1610", I2CDeviceType{"pxe1610", true}},
121     {"RAA228000", I2CDeviceType{"raa228000", true}},
122     {"RAA228004", I2CDeviceType{"raa228004", true}},
123     {"RAA228228", I2CDeviceType{"raa228228", true}},
124     {"RAA228620", I2CDeviceType{"raa228620", true}},
125     {"RAA229001", I2CDeviceType{"raa229001", true}},
126     {"RAA229004", I2CDeviceType{"raa229004", true}},
127     {"RAA229126", I2CDeviceType{"raa229126", true}},
128     {"RTQ6056", I2CDeviceType{"rtq6056", false}},
129     {"SBRMI", I2CDeviceType{"sbrmi", true}},
130     {"smpro_hwmon", I2CDeviceType{"smpro", false}},
131     {"TDA38640", I2CDeviceType{"tda38640", true}},
132     {"TPS53679", I2CDeviceType{"tps53679", true}},
133     {"TPS546D24", I2CDeviceType{"tps546d24", true}},
134     {"XDP710", I2CDeviceType{"xdp710", true}},
135     {"XDPE11280", I2CDeviceType{"xdpe11280", true}},
136     {"XDPE12284", I2CDeviceType{"xdpe12284", true}},
137     {"XDPE152C4", I2CDeviceType{"xdpe152c4", true}},
138 };
139 
140 enum class DevTypes
141 {
142     Unknown = 0,
143     HWMON,
144     IIO
145 };
146 
147 struct DevParams
148 {
149     unsigned int matchIndex = 0;
150     std::string matchRegEx;
151     std::string nameRegEx;
152 };
153 
154 namespace fs = std::filesystem;
155 
156 static boost::container::flat_map<std::string, std::shared_ptr<PSUSensor>>
157     sensors;
158 static boost::container::flat_map<std::string, std::unique_ptr<PSUCombineEvent>>
159     combineEvents;
160 static boost::container::flat_map<std::string, std::unique_ptr<PwmSensor>>
161     pwmSensors;
162 static boost::container::flat_map<std::string, std::string> sensorTable;
163 static boost::container::flat_map<std::string, PSUProperty> labelMatch;
164 static EventPathList eventMatch;
165 static EventPathList limitEventMatch;
166 
167 static boost::container::flat_map<size_t, bool> cpuPresence;
168 static boost::container::flat_map<DevTypes, DevParams> devParamMap;
169 
170 // Function CheckEvent will check each attribute from eventMatch table in the
171 // sysfs. If the attributes exists in sysfs, then store the complete path
172 // of the attribute into eventPathList.
checkEvent(const std::string & directory,const EventPathList & eventMatch,EventPathList & eventPathList)173 void checkEvent(const std::string& directory, const EventPathList& eventMatch,
174                 EventPathList& eventPathList)
175 {
176     for (const auto& match : eventMatch)
177     {
178         const std::vector<std::string>& eventAttrs = match.second;
179         const std::string& eventName = match.first;
180         for (const auto& eventAttr : eventAttrs)
181         {
182             std::string eventPath = directory;
183             eventPath += "/";
184             eventPath += eventAttr;
185 
186             std::ifstream eventFile(eventPath);
187             if (!eventFile.good())
188             {
189                 continue;
190             }
191 
192             eventPathList[eventName].push_back(eventPath);
193         }
194     }
195 }
196 
197 // Check Group Events which contains more than one targets in each combine
198 // events.
checkGroupEvent(const std::string & directory,GroupEventPathList & groupEventPathList)199 void checkGroupEvent(const std::string& directory,
200                      GroupEventPathList& groupEventPathList)
201 {
202     EventPathList pathList;
203     std::vector<fs::path> eventPaths;
204     if (!findFiles(fs::path(directory), R"(fan\d+_(alarm|fault))", eventPaths))
205     {
206         return;
207     }
208 
209     for (const auto& eventPath : eventPaths)
210     {
211         std::string attrName = eventPath.filename();
212         pathList[attrName.substr(0, attrName.find('_'))].push_back(eventPath);
213     }
214     groupEventPathList["FanFault"] = pathList;
215 }
216 
217 // Function checkEventLimits will check all the psu related xxx_input attributes
218 // in sysfs to see if xxx_crit_alarm xxx_lcrit_alarm xxx_max_alarm
219 // xxx_min_alarm exist, then store the existing paths of the alarm attributes
220 // to eventPathList.
checkEventLimits(const std::string & sensorPathStr,const EventPathList & limitEventMatch,EventPathList & eventPathList)221 void checkEventLimits(const std::string& sensorPathStr,
222                       const EventPathList& limitEventMatch,
223                       EventPathList& eventPathList)
224 {
225     auto attributePartPos = sensorPathStr.find_last_of('_');
226     if (attributePartPos == std::string::npos)
227     {
228         // There is no '_' in the string, skip it
229         return;
230     }
231     auto attributePart =
232         std::string_view(sensorPathStr).substr(attributePartPos + 1);
233     if (attributePart != "input")
234     {
235         // If the sensor is not xxx_input, skip it
236         return;
237     }
238 
239     auto prefixPart = sensorPathStr.substr(0, attributePartPos + 1);
240     for (const auto& limitMatch : limitEventMatch)
241     {
242         const std::vector<std::string>& limitEventAttrs = limitMatch.second;
243         const std::string& eventName = limitMatch.first;
244         for (const auto& limitEventAttr : limitEventAttrs)
245         {
246             auto limitEventPath = prefixPart + limitEventAttr;
247             std::ifstream eventFile(limitEventPath);
248             if (!eventFile.good())
249             {
250                 continue;
251             }
252             eventPathList[eventName].push_back(limitEventPath);
253         }
254     }
255 }
256 
checkPWMSensor(const fs::path & sensorPath,std::string & labelHead,const std::string & interfacePath,std::shared_ptr<sdbusplus::asio::connection> & dbusConnection,sdbusplus::asio::object_server & objectServer,const std::string & psuName)257 static void checkPWMSensor(
258     const fs::path& sensorPath, std::string& labelHead,
259     const std::string& interfacePath,
260     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
261     sdbusplus::asio::object_server& objectServer, const std::string& psuName)
262 {
263     if (!labelHead.starts_with("fan"))
264     {
265         return;
266     }
267     std::string labelHeadIndex = labelHead.substr(3);
268 
269     const std::string& sensorPathStr = sensorPath.string();
270     const std::string& pwmPathStr =
271         boost::replace_all_copy(sensorPathStr, "input", "target");
272     std::ifstream pwmFile(pwmPathStr);
273     if (!pwmFile.good())
274     {
275         return;
276     }
277 
278     auto findPWMSensor = pwmSensors.find(psuName + labelHead);
279     if (findPWMSensor != pwmSensors.end())
280     {
281         return;
282     }
283 
284     std::string name = "Pwm_";
285     name += psuName;
286     name += "_Fan_";
287     name += labelHeadIndex;
288 
289     std::string objPath = interfacePath;
290     objPath += "_Fan_";
291     objPath += labelHeadIndex;
292 
293     pwmSensors[psuName + labelHead] = std::make_unique<PwmSensor>(
294         name, pwmPathStr, dbusConnection, objectServer, objPath, "PSU");
295 }
296 
createSensorsCallback(boost::asio::io_context & io,sdbusplus::asio::object_server & objectServer,std::shared_ptr<sdbusplus::asio::connection> & dbusConnection,const ManagedObjectType & sensorConfigs,const std::shared_ptr<boost::container::flat_set<std::string>> & sensorsChanged,bool activateOnly)297 static void createSensorsCallback(
298     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
299     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
300     const ManagedObjectType& sensorConfigs,
301     const std::shared_ptr<boost::container::flat_set<std::string>>&
302         sensorsChanged,
303     bool activateOnly)
304 {
305     int numCreated = 0;
306     bool firstScan = sensorsChanged == nullptr;
307 
308     auto devices = instantiateDevices(sensorConfigs, sensors, sensorTypes);
309 
310     std::vector<fs::path> pmbusPaths;
311     findFiles(fs::path("/sys/bus/iio/devices"), "name", pmbusPaths);
312     findFiles(fs::path("/sys/class/hwmon"), "name", pmbusPaths);
313     if (pmbusPaths.empty())
314     {
315         std::cerr << "No PSU sensors in system\n";
316         return;
317     }
318 
319     boost::container::flat_set<std::string> directories;
320     for (const auto& pmbusPath : pmbusPaths)
321     {
322         EventPathList eventPathList;
323         GroupEventPathList groupEventPathList;
324 
325         std::ifstream nameFile(pmbusPath);
326         if (!nameFile.good())
327         {
328             std::cerr << "Failure finding pmbus path " << pmbusPath << "\n";
329             continue;
330         }
331 
332         std::string pmbusName;
333         std::getline(nameFile, pmbusName);
334         nameFile.close();
335 
336         if (sensorTypes.find(pmbusName) == sensorTypes.end())
337         {
338             // To avoid this error message, add your driver name to
339             // the pmbusNames vector at the top of this file.
340             std::cerr << "Driver name " << pmbusName
341                       << " not found in sensor whitelist\n";
342             continue;
343         }
344 
345         auto directory = pmbusPath.parent_path();
346 
347         auto ret = directories.insert(directory.string());
348         if (!ret.second)
349         {
350             std::cerr << "Duplicate path " << directory.string() << "\n";
351             continue; // check if path has already been searched
352         }
353 
354         DevTypes devType = DevTypes::HWMON;
355         std::string deviceName;
356         if (directory.parent_path() == "/sys/class/hwmon")
357         {
358             std::string devicePath = fs::canonical(directory / "device");
359             std::smatch match;
360             // Find /i2c-<bus>/<bus>-<address> match in device path
361             std::regex_search(devicePath, match, i2cDevRegex);
362             if (match.empty())
363             {
364                 std::cerr << "Found bad device path " << devicePath << "\n";
365                 continue;
366             }
367             // Extract <bus>-<address>
368             std::string matchStr = match[1];
369             deviceName = matchStr.substr(matchStr.find_last_of('/') + 1);
370         }
371         else
372         {
373             deviceName = fs::canonical(directory).parent_path().stem();
374             devType = DevTypes::IIO;
375         }
376 
377         size_t bus = 0;
378         size_t addr = 0;
379         if (!getDeviceBusAddr(deviceName, bus, addr))
380         {
381             continue;
382         }
383 
384         const SensorBaseConfigMap* baseConfig = nullptr;
385         const SensorData* sensorData = nullptr;
386         const std::string* interfacePath = nullptr;
387         std::string sensorType;
388         size_t thresholdConfSize = 0;
389 
390         for (const auto& [path, cfgData] : sensorConfigs)
391         {
392             sensorData = &cfgData;
393             for (const auto& [type, dt] : sensorTypes)
394             {
395                 auto sensorBase = sensorData->find(configInterfaceName(type));
396                 if (sensorBase != sensorData->end())
397                 {
398                     baseConfig = &sensorBase->second;
399                     sensorType = type;
400                     break;
401                 }
402             }
403             if (baseConfig == nullptr)
404             {
405                 std::cerr << "error finding base configuration for "
406                           << deviceName << "\n";
407                 continue;
408             }
409 
410             auto configBus = baseConfig->find("Bus");
411             auto configAddress = baseConfig->find("Address");
412 
413             if (configBus == baseConfig->end() ||
414                 configAddress == baseConfig->end())
415             {
416                 std::cerr << "error finding necessary entry in configuration\n";
417                 continue;
418             }
419 
420             const uint64_t* confBus =
421                 std::get_if<uint64_t>(&(configBus->second));
422             const uint64_t* confAddr =
423                 std::get_if<uint64_t>(&(configAddress->second));
424             if (confBus == nullptr || confAddr == nullptr)
425             {
426                 std::cerr
427                     << "Cannot get bus or address, invalid configuration\n";
428                 continue;
429             }
430 
431             if ((*confBus != bus) || (*confAddr != addr))
432             {
433                 if constexpr (debug)
434                 {
435                     std::cerr << "Configuration skipping " << *confBus << "-"
436                               << *confAddr << " because not " << bus << "-"
437                               << addr << "\n";
438                 }
439                 continue;
440             }
441 
442             std::vector<thresholds::Threshold> confThresholds;
443             if (!parseThresholdsFromConfig(*sensorData, confThresholds))
444             {
445                 std::cerr << "error populating total thresholds\n";
446             }
447             thresholdConfSize = confThresholds.size();
448 
449             interfacePath = &path.str;
450             break;
451         }
452         if (interfacePath == nullptr)
453         {
454             // To avoid this error message, add your export map entry,
455             // from Entity Manager, to sensorTypes at the top of this file.
456             std::cerr << "failed to find match for " << deviceName << "\n";
457             continue;
458         }
459 
460         auto findI2CDev = devices.find(*interfacePath);
461 
462         std::shared_ptr<I2CDevice> i2cDev;
463         if (findI2CDev != devices.end())
464         {
465             if (activateOnly && !findI2CDev->second.second)
466             {
467                 continue;
468             }
469             i2cDev = findI2CDev->second.first;
470         }
471 
472         auto findPSUName = baseConfig->find("Name");
473         if (findPSUName == baseConfig->end())
474         {
475             std::cerr << "could not determine configuration name for "
476                       << deviceName << "\n";
477             continue;
478         }
479         const std::string* psuName =
480             std::get_if<std::string>(&(findPSUName->second));
481         if (psuName == nullptr)
482         {
483             std::cerr << "Cannot find psu name, invalid configuration\n";
484             continue;
485         }
486 
487         auto findCPU = baseConfig->find("CPURequired");
488         if (findCPU != baseConfig->end())
489         {
490             size_t index = std::visit(VariantToIntVisitor(), findCPU->second);
491             auto presenceFind = cpuPresence.find(index);
492             if (presenceFind == cpuPresence.end() || !presenceFind->second)
493             {
494                 continue;
495             }
496         }
497 
498         // on rescans, only update sensors we were signaled by
499         if (!firstScan)
500         {
501             std::string psuNameStr = "/" + escapeName(*psuName);
502             auto it =
503                 std::find_if(sensorsChanged->begin(), sensorsChanged->end(),
504                              [psuNameStr](std::string& s) {
505                                  return s.ends_with(psuNameStr);
506                              });
507 
508             if (it == sensorsChanged->end())
509             {
510                 continue;
511             }
512             sensorsChanged->erase(it);
513         }
514         checkEvent(directory.string(), eventMatch, eventPathList);
515         checkGroupEvent(directory.string(), groupEventPathList);
516 
517         PowerState readState = getPowerState(*baseConfig);
518 
519         /* Check if there are more sensors in the same interface */
520         int i = 1;
521         std::vector<std::string> psuNames;
522         do
523         {
524             // Individual string fields: Name, Name1, Name2, Name3, ...
525             psuNames.push_back(
526                 escapeName(std::get<std::string>(findPSUName->second)));
527             findPSUName = baseConfig->find("Name" + std::to_string(i++));
528         } while (findPSUName != baseConfig->end());
529 
530         std::vector<fs::path> sensorPaths;
531         if (!findFiles(directory, devParamMap[devType].matchRegEx, sensorPaths,
532                        0))
533         {
534             std::cerr << "No PSU non-label sensor in PSU\n";
535             continue;
536         }
537 
538         /* read max value in sysfs for in, curr, power, temp, ... */
539         if (!findFiles(directory, R"(\w\d+_max$)", sensorPaths, 0))
540         {
541             if constexpr (debug)
542             {
543                 std::cerr << "No max name in PSU \n";
544             }
545         }
546 
547         float pollRate = getPollRate(*baseConfig, PSUSensor::defaultSensorPoll);
548 
549         /* Find array of labels to be exposed if it is defined in config */
550         std::vector<std::string> findLabels;
551         auto findLabelObj = baseConfig->find("Labels");
552         if (findLabelObj != baseConfig->end())
553         {
554             findLabels =
555                 std::get<std::vector<std::string>>(findLabelObj->second);
556         }
557 
558         std::regex sensorNameRegEx(devParamMap[devType].nameRegEx);
559         std::smatch matches;
560 
561         for (const auto& sensorPath : sensorPaths)
562         {
563             bool maxLabel = false;
564             std::string labelHead;
565             std::string sensorPathStr = sensorPath.string();
566             std::string sensorNameStr = sensorPath.filename();
567             std::string sensorNameSubStr;
568             if (std::regex_search(sensorNameStr, matches, sensorNameRegEx))
569             {
570                 // hwmon *_input filename without number:
571                 // in, curr, power, temp, ...
572                 // iio in_*_raw filename without number:
573                 // voltage, temp, pressure, ...
574                 sensorNameSubStr = matches[devParamMap[devType].matchIndex];
575             }
576             else
577             {
578                 std::cerr << "Could not extract the alpha prefix from "
579                           << sensorNameStr;
580                 continue;
581             }
582 
583             std::string labelPath;
584 
585             if (devType == DevTypes::HWMON)
586             {
587                 /* find and differentiate _max and _input to replace "label" */
588                 size_t pos = sensorPathStr.find('_');
589                 if (pos != std::string::npos)
590                 {
591                     std::string sensorPathStrMax = sensorPathStr.substr(pos);
592                     if (sensorPathStrMax == "_max")
593                     {
594                         labelPath = boost::replace_all_copy(sensorPathStr,
595                                                             "max", "label");
596                         maxLabel = true;
597                     }
598                     else
599                     {
600                         labelPath = boost::replace_all_copy(sensorPathStr,
601                                                             "input", "label");
602                         maxLabel = false;
603                     }
604                 }
605                 else
606                 {
607                     continue;
608                 }
609 
610                 std::ifstream labelFile(labelPath);
611                 if (!labelFile.good())
612                 {
613                     if constexpr (debug)
614                     {
615                         std::cerr << "Input file " << sensorPath
616                                   << " has no corresponding label file\n";
617                     }
618                     // hwmon *_input filename with number:
619                     // temp1, temp2, temp3, ...
620                     labelHead =
621                         sensorNameStr.substr(0, sensorNameStr.find('_'));
622                 }
623                 else
624                 {
625                     std::string label;
626                     std::getline(labelFile, label);
627                     labelFile.close();
628                     auto findSensor = sensors.find(label);
629                     if (findSensor != sensors.end())
630                     {
631                         continue;
632                     }
633 
634                     // hwmon corresponding *_label file contents:
635                     // vin1, vout1, ...
636                     labelHead = label.substr(0, label.find(' '));
637                 }
638 
639                 /* append "max" for labelMatch */
640                 if (maxLabel)
641                 {
642                     labelHead.insert(0, "max");
643                 }
644 
645                 checkPWMSensor(sensorPath, labelHead, *interfacePath,
646                                dbusConnection, objectServer, psuNames[0]);
647             }
648             else if (devType == DevTypes::IIO)
649             {
650                 auto findIIOHyphen = sensorNameStr.find_last_of('_');
651                 labelHead = sensorNameStr.substr(0, findIIOHyphen);
652             }
653 
654             if constexpr (debug)
655             {
656                 std::cerr << "Sensor type=\"" << sensorNameSubStr
657                           << "\" label=\"" << labelHead << "\"\n";
658             }
659 
660             if (!findLabels.empty())
661             {
662                 /* Check if this labelHead is enabled in config file */
663                 if (std::find(findLabels.begin(), findLabels.end(),
664                               labelHead) == findLabels.end())
665                 {
666                     if constexpr (debug)
667                     {
668                         std::cerr << "could not find " << labelHead
669                                   << " in the Labels list\n";
670                     }
671                     continue;
672                 }
673             }
674 
675             auto findProperty = labelMatch.find(sensorNameSubStr);
676             if (findProperty == labelMatch.end())
677             {
678                 if constexpr (debug)
679                 {
680                     std::cerr << "Could not find matching default property for "
681                               << sensorNameSubStr << "\n";
682                 }
683                 continue;
684             }
685 
686             // Protect the hardcoded labelMatch list from changes,
687             // by making a copy and modifying that instead.
688             // Avoid bleedthrough of one device's customizations to
689             // the next device, as each should be independently customizable.
690             PSUProperty psuProperty = findProperty->second;
691 
692             // Use label head as prefix for reading from config file,
693             // example if temp1: temp1_Name, temp1_Scale, temp1_Min, ...
694             std::string keyName = labelHead + "_Name";
695             std::string keyScale = labelHead + "_Scale";
696             std::string keyMin = labelHead + "_Min";
697             std::string keyMax = labelHead + "_Max";
698             std::string keyOffset = labelHead + "_Offset";
699             std::string keyPowerState = labelHead + "_PowerState";
700 
701             bool customizedName = false;
702             auto findCustomName = baseConfig->find(keyName);
703             if (findCustomName != baseConfig->end())
704             {
705                 try
706                 {
707                     psuProperty.labelTypeName = std::visit(
708                         VariantToStringVisitor(), findCustomName->second);
709                 }
710                 catch (const std::invalid_argument&)
711                 {
712                     std::cerr << "Unable to parse " << keyName << "\n";
713                     continue;
714                 }
715 
716                 // All strings are valid, including empty string
717                 customizedName = true;
718             }
719 
720             bool customizedScale = false;
721             auto findCustomScale = baseConfig->find(keyScale);
722             if (findCustomScale != baseConfig->end())
723             {
724                 try
725                 {
726                     psuProperty.sensorScaleFactor = std::visit(
727                         VariantToUnsignedIntVisitor(), findCustomScale->second);
728                 }
729                 catch (const std::invalid_argument&)
730                 {
731                     std::cerr << "Unable to parse " << keyScale << "\n";
732                     continue;
733                 }
734 
735                 // Avoid later division by zero
736                 if (psuProperty.sensorScaleFactor > 0)
737                 {
738                     customizedScale = true;
739                 }
740                 else
741                 {
742                     std::cerr << "Unable to accept " << keyScale << "\n";
743                     continue;
744                 }
745             }
746 
747             auto findCustomMin = baseConfig->find(keyMin);
748             if (findCustomMin != baseConfig->end())
749             {
750                 try
751                 {
752                     psuProperty.minReading = std::visit(
753                         VariantToDoubleVisitor(), findCustomMin->second);
754                 }
755                 catch (const std::invalid_argument&)
756                 {
757                     std::cerr << "Unable to parse " << keyMin << "\n";
758                     continue;
759                 }
760             }
761 
762             auto findCustomMax = baseConfig->find(keyMax);
763             if (findCustomMax != baseConfig->end())
764             {
765                 try
766                 {
767                     psuProperty.maxReading = std::visit(
768                         VariantToDoubleVisitor(), findCustomMax->second);
769                 }
770                 catch (const std::invalid_argument&)
771                 {
772                     std::cerr << "Unable to parse " << keyMax << "\n";
773                     continue;
774                 }
775             }
776 
777             auto findCustomOffset = baseConfig->find(keyOffset);
778             if (findCustomOffset != baseConfig->end())
779             {
780                 try
781                 {
782                     psuProperty.sensorOffset = std::visit(
783                         VariantToDoubleVisitor(), findCustomOffset->second);
784                 }
785                 catch (const std::invalid_argument&)
786                 {
787                     std::cerr << "Unable to parse " << keyOffset << "\n";
788                     continue;
789                 }
790             }
791 
792             // if we find label head power state set ，override the powerstate.
793             auto findPowerState = baseConfig->find(keyPowerState);
794             if (findPowerState != baseConfig->end())
795             {
796                 std::string powerState = std::visit(VariantToStringVisitor(),
797                                                     findPowerState->second);
798                 setReadState(powerState, readState);
799             }
800             if (!(psuProperty.minReading < psuProperty.maxReading))
801             {
802                 std::cerr << "Min must be less than Max\n";
803                 continue;
804             }
805 
806             // If the sensor name is being customized by config file,
807             // then prefix/suffix composition becomes not necessary,
808             // and in fact not wanted, because it gets in the way.
809             std::string psuNameFromIndex;
810             std::string nameIndexStr = "1";
811             if (!customizedName)
812             {
813                 /* Find out sensor name index for this label */
814                 std::regex rgx("[A-Za-z]+([0-9]+)");
815                 size_t nameIndex{0};
816                 if (std::regex_search(labelHead, matches, rgx))
817                 {
818                     nameIndexStr = matches[1];
819                     nameIndex = std::stoi(nameIndexStr);
820 
821                     // Decrement to preserve alignment, because hwmon
822                     // human-readable filenames and labels use 1-based
823                     // numbering, but the "Name", "Name1", "Name2", etc. naming
824                     // convention (the psuNames vector) uses 0-based numbering.
825                     if (nameIndex > 0)
826                     {
827                         --nameIndex;
828                     }
829                 }
830                 else
831                 {
832                     nameIndex = 0;
833                 }
834 
835                 if (psuNames.size() <= nameIndex)
836                 {
837                     std::cerr << "Could not pair " << labelHead
838                               << " with a Name field\n";
839                     continue;
840                 }
841 
842                 psuNameFromIndex = psuNames[nameIndex];
843 
844                 if constexpr (debug)
845                 {
846                     std::cerr << "Sensor label head " << labelHead
847                               << " paired with " << psuNameFromIndex
848                               << " at index " << nameIndex << "\n";
849                 }
850             }
851 
852             if (devType == DevTypes::HWMON)
853             {
854                 checkEventLimits(sensorPathStr, limitEventMatch, eventPathList);
855             }
856 
857             // Similarly, if sensor scaling factor is being customized,
858             // then the below power-of-10 constraint becomes unnecessary,
859             // as config should be able to specify an arbitrary divisor.
860             unsigned int factor = psuProperty.sensorScaleFactor;
861             if (!customizedScale)
862             {
863                 // Preserve existing usage of hardcoded labelMatch table below
864                 factor = std::pow(10.0, factor);
865 
866                 /* Change first char of substring to uppercase */
867                 char firstChar =
868                     static_cast<char>(std::toupper(sensorNameSubStr[0]));
869                 std::string strScaleFactor =
870                     firstChar + sensorNameSubStr.substr(1) + "ScaleFactor";
871 
872                 // Preserve existing configs by accepting earlier syntax,
873                 // example CurrScaleFactor, PowerScaleFactor, ...
874                 auto findScaleFactor = baseConfig->find(strScaleFactor);
875                 if (findScaleFactor != baseConfig->end())
876                 {
877                     factor = std::visit(VariantToIntVisitor(),
878                                         findScaleFactor->second);
879                 }
880 
881                 if constexpr (debug)
882                 {
883                     std::cerr << "Sensor scaling factor " << factor
884                               << " string " << strScaleFactor << "\n";
885                 }
886             }
887 
888             std::vector<thresholds::Threshold> sensorThresholds;
889             if (!parseThresholdsFromConfig(*sensorData, sensorThresholds,
890                                            &labelHead))
891             {
892                 std::cerr << "error populating thresholds for "
893                           << sensorNameSubStr << "\n";
894             }
895 
896             auto findSensorUnit = sensorTable.find(sensorNameSubStr);
897             if (findSensorUnit == sensorTable.end())
898             {
899                 std::cerr << sensorNameSubStr
900                           << " is not a recognized sensor type\n";
901                 continue;
902             }
903 
904             if constexpr (debug)
905             {
906                 std::cerr << "Sensor properties: Name \""
907                           << psuProperty.labelTypeName << "\" Scale "
908                           << psuProperty.sensorScaleFactor << " Min "
909                           << psuProperty.minReading << " Max "
910                           << psuProperty.maxReading << " Offset "
911                           << psuProperty.sensorOffset << "\n";
912             }
913 
914             std::string sensorName = psuProperty.labelTypeName;
915             if (customizedName)
916             {
917                 if (sensorName.empty())
918                 {
919                     // Allow selective disabling of an individual sensor,
920                     // by customizing its name to an empty string.
921                     std::cerr << "Sensor disabled, empty string\n";
922                     continue;
923                 }
924             }
925             else
926             {
927                 // Sensor name not customized, do prefix/suffix composition,
928                 // preserving default behavior by using psuNameFromIndex.
929                 sensorName = psuNameFromIndex + " " + psuProperty.labelTypeName;
930 
931                 // The labelTypeName of a fan can be:
932                 // "Fan Speed 1", "Fan Speed 2", "Fan Speed 3" ...
933                 if (labelHead == "fan" + nameIndexStr)
934                 {
935                     sensorName += nameIndexStr;
936                 }
937             }
938 
939             if constexpr (debug)
940             {
941                 std::cerr << "Sensor name \"" << sensorName << "\" path \""
942                           << sensorPathStr << "\" type \"" << sensorType
943                           << "\"\n";
944             }
945             // destruct existing one first if already created
946 
947             auto& sensor = sensors[sensorName];
948             if (!activateOnly)
949             {
950                 sensor = nullptr;
951             }
952 
953             if (sensor != nullptr)
954             {
955                 sensor->activate(sensorPathStr, i2cDev);
956             }
957             else
958             {
959                 sensors[sensorName] = std::make_shared<PSUSensor>(
960                     sensorPathStr, sensorType, objectServer, dbusConnection, io,
961                     sensorName, std::move(sensorThresholds), *interfacePath,
962                     readState, findSensorUnit->second, factor,
963                     psuProperty.maxReading, psuProperty.minReading,
964                     psuProperty.sensorOffset, labelHead, thresholdConfSize,
965                     pollRate, i2cDev);
966                 sensors[sensorName]->setupRead();
967                 ++numCreated;
968                 if constexpr (debug)
969                 {
970                     std::cerr
971                         << "Created " << numCreated << " sensors so far\n";
972                 }
973             }
974         }
975 
976         if (devType == DevTypes::HWMON)
977         {
978             // OperationalStatus event
979             combineEvents[*psuName + "OperationalStatus"] = nullptr;
980             combineEvents[*psuName + "OperationalStatus"] =
981                 std::make_unique<PSUCombineEvent>(
982                     objectServer, dbusConnection, io, *psuName, readState,
983                     eventPathList, groupEventPathList, "OperationalStatus",
984                     pollRate);
985         }
986     }
987 
988     if constexpr (debug)
989     {
990         std::cerr << "Created total of " << numCreated << " sensors\n";
991     }
992 }
993 
994 static void
getPresentCpus(std::shared_ptr<sdbusplus::asio::connection> & dbusConnection)995     getPresentCpus(std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
996 {
997     static const int depth = 2;
998     static const int numKeys = 1;
999     GetSubTreeType cpuSubTree;
1000 
1001     try
1002     {
1003         auto getItems = dbusConnection->new_method_call(
1004             mapper::busName, mapper::path, mapper::interface, mapper::subtree);
1005         getItems.append(cpuInventoryPath, static_cast<int32_t>(depth),
1006                         std::array<const char*, numKeys>{
1007                             "xyz.openbmc_project.Inventory.Item"});
1008         auto getItemsResp = dbusConnection->call(getItems);
1009         getItemsResp.read(cpuSubTree);
1010     }
1011     catch (sdbusplus::exception_t& e)
1012     {
1013         std::cerr << "error getting inventory item subtree: " << e.what()
1014                   << "\n";
1015         return;
1016     }
1017 
1018     for (const auto& [path, objDict] : cpuSubTree)
1019     {
1020         auto obj = sdbusplus::message::object_path(path).filename();
1021         boost::to_lower(obj);
1022 
1023         if (!obj.starts_with("cpu") || objDict.empty())
1024         {
1025             continue;
1026         }
1027         const std::string& owner = objDict.begin()->first;
1028 
1029         std::variant<bool> respValue;
1030         try
1031         {
1032             auto getPresence = dbusConnection->new_method_call(
1033                 owner.c_str(), path.c_str(), "org.freedesktop.DBus.Properties",
1034                 "Get");
1035             getPresence.append("xyz.openbmc_project.Inventory.Item", "Present");
1036             auto resp = dbusConnection->call(getPresence);
1037             resp.read(respValue);
1038         }
1039         catch (sdbusplus::exception_t& e)
1040         {
1041             std::cerr << "Error in getting CPU presence: " << e.what() << "\n";
1042             continue;
1043         }
1044 
1045         auto* present = std::get_if<bool>(&respValue);
1046         if (present != nullptr && *present)
1047         {
1048             int cpuIndex = 0;
1049             try
1050             {
1051                 cpuIndex = std::stoi(obj.substr(obj.size() - 1));
1052             }
1053             catch (const std::exception& e)
1054             {
1055                 std::cerr << "Error converting CPU index, " << e.what() << '\n';
1056                 continue;
1057             }
1058             cpuPresence[cpuIndex] = *present;
1059         }
1060     }
1061 }
1062 
createSensors(boost::asio::io_context & io,sdbusplus::asio::object_server & objectServer,std::shared_ptr<sdbusplus::asio::connection> & dbusConnection,const std::shared_ptr<boost::container::flat_set<std::string>> & sensorsChanged,bool activateOnly)1063 void createSensors(
1064     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
1065     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
1066     const std::shared_ptr<boost::container::flat_set<std::string>>&
1067         sensorsChanged,
1068     bool activateOnly)
1069 {
1070     auto getter = std::make_shared<GetSensorConfiguration>(
1071         dbusConnection, [&io, &objectServer, &dbusConnection, sensorsChanged,
1072                          activateOnly](const ManagedObjectType& sensorConfigs) {
1073             createSensorsCallback(io, objectServer, dbusConnection,
1074                                   sensorConfigs, sensorsChanged, activateOnly);
1075         });
1076     std::vector<std::string> types(sensorTypes.size());
1077     for (const auto& [type, dt] : sensorTypes)
1078     {
1079         types.push_back(type);
1080     }
1081     getter->getConfiguration(types);
1082 }
1083 
propertyInitialize()1084 void propertyInitialize()
1085 {
1086     sensorTable = {{"power", sensor_paths::unitWatts},
1087                    {"curr", sensor_paths::unitAmperes},
1088                    {"temp", sensor_paths::unitDegreesC},
1089                    {"in", sensor_paths::unitVolts},
1090                    {"voltage", sensor_paths::unitVolts},
1091                    {"fan", sensor_paths::unitRPMs}};
1092 
1093     labelMatch = {
1094         {"pin", PSUProperty("Input Power", 3000, 0, 6, 0)},
1095         {"pout", PSUProperty("Output Power", 3000, 0, 6, 0)},
1096         {"power", PSUProperty("Output Power", 3000, 0, 6, 0)},
1097         {"maxpin", PSUProperty("Max Input Power", 3000, 0, 6, 0)},
1098         {"vin", PSUProperty("Input Voltage", 300, 0, 3, 0)},
1099         {"maxvin", PSUProperty("Max Input Voltage", 300, 0, 3, 0)},
1100         {"in_voltage", PSUProperty("Output Voltage", 255, 0, 3, 0)},
1101         {"voltage", PSUProperty("Output Voltage", 255, 0, 3, 0)},
1102         {"vout", PSUProperty("Output Voltage", 255, 0, 3, 0)},
1103         {"vmon", PSUProperty("Auxiliary Input Voltage", 255, 0, 3, 0)},
1104         {"in", PSUProperty("Output Voltage", 255, 0, 3, 0)},
1105         {"iin", PSUProperty("Input Current", 20, 0, 3, 0)},
1106         {"iout", PSUProperty("Output Current", 255, 0, 3, 0)},
1107         {"curr", PSUProperty("Output Current", 255, 0, 3, 0)},
1108         {"maxiout", PSUProperty("Max Output Current", 255, 0, 3, 0)},
1109         {"temp", PSUProperty("Temperature", 127, -128, 3, 0)},
1110         {"maxtemp", PSUProperty("Max Temperature", 127, -128, 3, 0)},
1111         {"fan", PSUProperty("Fan Speed ", 30000, 0, 0, 0)}};
1112 
1113     limitEventMatch = {{"PredictiveFailure", {"max_alarm", "min_alarm"}},
1114                        {"Failure", {"crit_alarm", "lcrit_alarm"}}};
1115 
1116     eventMatch = {{"PredictiveFailure", {"power1_alarm"}},
1117                   {"Failure", {"in2_alarm"}},
1118                   {"ACLost", {"in1_beep"}},
1119                   {"ConfigureError", {"in1_fault"}}};
1120 
1121     devParamMap = {
1122         {DevTypes::HWMON, {1, R"(\w\d+_input$)", "([A-Za-z]+)[0-9]*_"}},
1123         {DevTypes::IIO,
1124          {2, R"(\w+_(raw|input)$)", "^(in|out)_([A-Za-z]+)[0-9]*_"}}};
1125 }
1126 
powerStateChanged(PowerState type,bool newState,boost::container::flat_map<std::string,std::shared_ptr<PSUSensor>> & sensors,boost::asio::io_context & io,sdbusplus::asio::object_server & objectServer,std::shared_ptr<sdbusplus::asio::connection> & dbusConnection)1127 static void powerStateChanged(
1128     PowerState type, bool newState,
1129     boost::container::flat_map<std::string, std::shared_ptr<PSUSensor>>&
1130         sensors,
1131     boost::asio::io_context& io, sdbusplus::asio::object_server& objectServer,
1132     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
1133 {
1134     if (newState)
1135     {
1136         createSensors(io, objectServer, dbusConnection, nullptr, true);
1137     }
1138     else
1139     {
1140         for (auto& [path, sensor] : sensors)
1141         {
1142             if (sensor != nullptr && sensor->readState == type)
1143             {
1144                 sensor->deactivate();
1145             }
1146         }
1147     }
1148 }
1149 
main()1150 int main()
1151 {
1152     boost::asio::io_context io;
1153     auto systemBus = std::make_shared<sdbusplus::asio::connection>(io);
1154 
1155     sdbusplus::asio::object_server objectServer(systemBus, true);
1156     objectServer.add_manager("/xyz/openbmc_project/sensors");
1157     objectServer.add_manager("/xyz/openbmc_project/control");
1158     systemBus->request_name("xyz.openbmc_project.PSUSensor");
1159     auto sensorsChanged =
1160         std::make_shared<boost::container::flat_set<std::string>>();
1161 
1162     propertyInitialize();
1163 
1164     auto powerCallBack = [&io, &objectServer,
1165                           &systemBus](PowerState type, bool state) {
1166         powerStateChanged(type, state, sensors, io, objectServer, systemBus);
1167     };
1168 
1169     setupPowerMatchCallback(systemBus, powerCallBack);
1170 
1171     boost::asio::post(io, [&]() {
1172         createSensors(io, objectServer, systemBus, nullptr, false);
1173     });
1174     boost::asio::steady_timer filterTimer(io);
1175     std::function<void(sdbusplus::message_t&)> eventHandler =
1176         [&](sdbusplus::message_t& message) {
1177             if (message.is_method_error())
1178             {
1179                 std::cerr << "callback method error\n";
1180                 return;
1181             }
1182             sensorsChanged->insert(message.get_path());
1183             filterTimer.expires_after(std::chrono::seconds(3));
1184             filterTimer.async_wait([&](const boost::system::error_code& ec) {
1185                 if (ec == boost::asio::error::operation_aborted)
1186                 {
1187                     return;
1188                 }
1189                 if (ec)
1190                 {
1191                     std::cerr << "timer error\n";
1192                 }
1193                 createSensors(io, objectServer, systemBus, sensorsChanged,
1194                               false);
1195             });
1196         };
1197 
1198     boost::asio::steady_timer cpuFilterTimer(io);
1199     std::function<void(sdbusplus::message_t&)> cpuPresenceHandler =
1200         [&](sdbusplus::message_t& message) {
1201             std::string path = message.get_path();
1202             boost::to_lower(path);
1203 
1204             sdbusplus::message::object_path cpuPath(path);
1205             std::string cpuName = cpuPath.filename();
1206             if (!cpuName.starts_with("cpu"))
1207             {
1208                 return;
1209             }
1210             size_t index = 0;
1211             try
1212             {
1213                 index = std::stoi(path.substr(path.size() - 1));
1214             }
1215             catch (const std::invalid_argument&)
1216             {
1217                 std::cerr << "Found invalid path " << path << "\n";
1218                 return;
1219             }
1220 
1221             std::string objectName;
1222             boost::container::flat_map<std::string, std::variant<bool>> values;
1223             message.read(objectName, values);
1224             auto findPresence = values.find("Present");
1225             if (findPresence == values.end())
1226             {
1227                 return;
1228             }
1229             try
1230             {
1231                 cpuPresence[index] = std::get<bool>(findPresence->second);
1232             }
1233             catch (const std::bad_variant_access& err)
1234             {
1235                 return;
1236             }
1237 
1238             if (!cpuPresence[index])
1239             {
1240                 return;
1241             }
1242             cpuFilterTimer.expires_after(std::chrono::seconds(1));
1243             cpuFilterTimer.async_wait([&](const boost::system::error_code& ec) {
1244                 if (ec == boost::asio::error::operation_aborted)
1245                 {
1246                     return;
1247                 }
1248                 if (ec)
1249                 {
1250                     std::cerr << "timer error\n";
1251                     return;
1252                 }
1253                 createSensors(io, objectServer, systemBus, nullptr, false);
1254             });
1255         };
1256 
1257     std::vector<std::unique_ptr<sdbusplus::bus::match_t>> matches =
1258         setupPropertiesChangedMatches(*systemBus, sensorTypes, eventHandler);
1259 
1260     matches.emplace_back(std::make_unique<sdbusplus::bus::match_t>(
1261         static_cast<sdbusplus::bus_t&>(*systemBus),
1262         "type='signal',member='PropertiesChanged',path_namespace='" +
1263             std::string(cpuInventoryPath) +
1264             "',arg0namespace='xyz.openbmc_project.Inventory.Item'",
1265         cpuPresenceHandler));
1266 
1267     getPresentCpus(systemBus);
1268 
1269     setupManufacturingModeMatch(*systemBus);
1270     io.run();
1271 }
1272