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