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