1 #pragma once
2
3 #include "VariantVisitors.hpp"
4
5 #include <boost/algorithm/string/replace.hpp>
6 #include <boost/asio/steady_timer.hpp>
7 #include <boost/container/flat_map.hpp>
8 #include <sdbusplus/asio/connection.hpp>
9 #include <sdbusplus/asio/object_server.hpp>
10 #include <sdbusplus/bus/match.hpp>
11 #include <sdbusplus/message.hpp>
12 #include <sdbusplus/message/native_types.hpp>
13
14 #include <algorithm>
15 #include <charconv>
16 #include <chrono>
17 #include <cmath>
18 #include <cstddef>
19 #include <cstdint>
20 #include <filesystem>
21 #include <functional>
22 #include <iostream>
23 #include <memory>
24 #include <optional>
25 #include <regex>
26 #include <set>
27 #include <span>
28 #include <stdexcept>
29 #include <string>
30 #include <string_view>
31 #include <system_error>
32 #include <tuple>
33 #include <utility>
34 #include <variant>
35 #include <vector>
36
37 const constexpr char* jsonStore = "/var/configuration/flattened.json";
38 const constexpr char* inventoryPath = "/xyz/openbmc_project/inventory";
39 const constexpr char* entityManagerName = "xyz.openbmc_project.EntityManager";
40
41 constexpr const char* cpuInventoryPath =
42 "/xyz/openbmc_project/inventory/system/chassis/motherboard";
43 const std::regex illegalDbusRegex("[^A-Za-z0-9_]");
44
45 using BasicVariantType =
46 std::variant<std::vector<std::string>, std::string, int64_t, uint64_t,
47 double, int32_t, uint32_t, int16_t, uint16_t, uint8_t, bool>;
48 using SensorBaseConfigMap =
49 boost::container::flat_map<std::string, BasicVariantType>;
50 using SensorBaseConfiguration = std::pair<std::string, SensorBaseConfigMap>;
51 using SensorData = boost::container::flat_map<std::string, SensorBaseConfigMap>;
52 using ManagedObjectType =
53 boost::container::flat_map<sdbusplus::message::object_path, SensorData>;
54
55 using GetSubTreeType = std::vector<
56 std::pair<std::string,
57 std::vector<std::pair<std::string, std::vector<std::string>>>>>;
58 using Association = std::tuple<std::string, std::string, std::string>;
59
escapeName(const std::string & sensorName)60 inline std::string escapeName(const std::string& sensorName)
61 {
62 return boost::replace_all_copy(sensorName, " ", "_");
63 }
64
65 enum class PowerState
66 {
67 on,
68 biosPost,
69 always,
70 chassisOn
71 };
72
73 std::optional<std::string> openAndRead(const std::string& hwmonFile);
74 std::optional<std::string> getFullHwmonFilePath(
75 const std::string& directory, const std::string& hwmonBaseName,
76 const std::set<std::string>& permitSet);
77 std::set<std::string> getPermitSet(const SensorBaseConfigMap& config);
78 bool findFiles(const std::filesystem::path& dirPath,
79 std::string_view matchString,
80 std::vector<std::filesystem::path>& foundPaths,
81 int symlinkDepth = 1);
82 bool isPowerOn();
83 bool hasBiosPost();
84 bool isChassisOn();
85 void setupPowerMatchCallback(
86 const std::shared_ptr<sdbusplus::asio::connection>& conn,
87 std::function<void(PowerState type, bool state)>&& callback);
88 void setupPowerMatch(const std::shared_ptr<sdbusplus::asio::connection>& conn);
89 bool getSensorConfiguration(
90 const std::string& type,
91 const std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
92 ManagedObjectType& resp, bool useCache);
93
94 void createAssociation(
95 std::shared_ptr<sdbusplus::asio::dbus_interface>& association,
96 const std::string& path);
97
98 // replaces limits if MinReading and MaxReading are found.
99 void findLimits(std::pair<double, double>& limits,
100 const SensorBaseConfiguration* data);
101
102 bool readingStateGood(const PowerState& powerState);
103
104 constexpr const char* configInterfacePrefix =
105 "xyz.openbmc_project.Configuration.";
106
configInterfaceName(const std::string & type)107 inline std::string configInterfaceName(const std::string& type)
108 {
109 return std::string(configInterfacePrefix) + type;
110 }
111
112 namespace mapper
113 {
114 constexpr const char* busName = "xyz.openbmc_project.ObjectMapper";
115 constexpr const char* path = "/xyz/openbmc_project/object_mapper";
116 constexpr const char* interface = "xyz.openbmc_project.ObjectMapper";
117 constexpr const char* subtree = "GetSubTree";
118 } // namespace mapper
119
120 namespace properties
121 {
122 constexpr const char* interface = "org.freedesktop.DBus.Properties";
123 constexpr const char* get = "Get";
124 constexpr const char* set = "Set";
125 } // namespace properties
126
127 namespace power
128 {
129 const static constexpr char* busname = "xyz.openbmc_project.State.Host0";
130 const static constexpr char* interface = "xyz.openbmc_project.State.Host";
131 const static constexpr char* path = "/xyz/openbmc_project/state/host0";
132 const static constexpr char* property = "CurrentHostState";
133 } // namespace power
134
135 namespace chassis
136 {
137 const static constexpr char* busname = "xyz.openbmc_project.State.Chassis0";
138 const static constexpr char* interface = "xyz.openbmc_project.State.Chassis";
139 const static constexpr char* path = "/xyz/openbmc_project/state/chassis0";
140 const static constexpr char* property = "CurrentPowerState";
141 const static constexpr char* sOn = ".On";
142 } // namespace chassis
143
144 namespace post
145 {
146 const static constexpr char* busname = "xyz.openbmc_project.State.Host0";
147 const static constexpr char* interface =
148 "xyz.openbmc_project.State.OperatingSystem.Status";
149 const static constexpr char* path = "/xyz/openbmc_project/state/host0";
150 const static constexpr char* property = "OperatingSystemState";
151 } // namespace post
152
153 namespace association
154 {
155 const static constexpr char* interface =
156 "xyz.openbmc_project.Association.Definitions";
157 } // namespace association
158
159 template <typename T>
loadVariant(const SensorBaseConfigMap & data,const std::string & key)160 inline T loadVariant(const SensorBaseConfigMap& data, const std::string& key)
161 {
162 auto it = data.find(key);
163 if (it == data.end())
164 {
165 std::cerr << "Configuration missing " << key << "\n";
166 throw std::invalid_argument("Key Missing");
167 }
168 if constexpr (std::is_same_v<T, double>)
169 {
170 return std::visit(VariantToDoubleVisitor(), it->second);
171 }
172 else if constexpr (std::is_unsigned_v<T>)
173 {
174 return std::visit(VariantToUnsignedIntVisitor(), it->second);
175 }
176 else if constexpr (std::is_same_v<T, std::string>)
177 {
178 return std::visit(VariantToStringVisitor(), it->second);
179 }
180 else
181 {
182 static_assert(!std::is_same_v<T, T>, "Type Not Implemented");
183 }
184 }
185
setReadState(const std::string & str,PowerState & val)186 inline void setReadState(const std::string& str, PowerState& val)
187 {
188 if (str == "On")
189 {
190 val = PowerState::on;
191 }
192 else if (str == "BiosPost")
193 {
194 val = PowerState::biosPost;
195 }
196 else if (str == "Always")
197 {
198 val = PowerState::always;
199 }
200 else if (str == "ChassisOn")
201 {
202 val = PowerState::chassisOn;
203 }
204 }
205
getPowerState(const SensorBaseConfigMap & cfg)206 inline PowerState getPowerState(const SensorBaseConfigMap& cfg)
207 {
208 PowerState state = PowerState::always;
209 auto findPowerState = cfg.find("PowerState");
210 if (findPowerState != cfg.end())
211 {
212 std::string powerState =
213 std::visit(VariantToStringVisitor(), findPowerState->second);
214 setReadState(powerState, state);
215 }
216 return state;
217 }
218
getPollRate(const SensorBaseConfigMap & cfg,float dflt)219 inline float getPollRate(const SensorBaseConfigMap& cfg, float dflt)
220 {
221 float pollRate = dflt;
222 auto findPollRate = cfg.find("PollRate");
223 if (findPollRate != cfg.end())
224 {
225 pollRate = std::visit(VariantToFloatVisitor(), findPollRate->second);
226 if (!std::isfinite(pollRate) || pollRate <= 0.0F)
227 {
228 pollRate = dflt; // poll time invalid, fall back to default
229 }
230 }
231 return pollRate;
232 }
233
setLed(const std::shared_ptr<sdbusplus::asio::connection> & conn,const std::string & name,bool on)234 inline void setLed(const std::shared_ptr<sdbusplus::asio::connection>& conn,
235 const std::string& name, bool on)
236 {
237 conn->async_method_call(
238 [name](const boost::system::error_code ec) {
239 if (ec)
240 {
241 std::cerr << "Failed to set LED " << name << "\n";
242 }
243 },
244 "xyz.openbmc_project.LED.GroupManager",
245 "/xyz/openbmc_project/led/groups/" + name, properties::interface,
246 properties::set, "xyz.openbmc_project.Led.Group", "Asserted",
247 std::variant<bool>(on));
248 }
249
250 void createInventoryAssoc(
251 const std::shared_ptr<sdbusplus::asio::connection>& conn,
252 const std::shared_ptr<sdbusplus::asio::dbus_interface>& association,
253 const std::string& path);
254
255 struct GetSensorConfiguration :
256 std::enable_shared_from_this<GetSensorConfiguration>
257 {
GetSensorConfigurationGetSensorConfiguration258 GetSensorConfiguration(
259 std::shared_ptr<sdbusplus::asio::connection> connection,
260 std::function<void(ManagedObjectType& resp)>&& callbackFunc) :
261 dbusConnection(std::move(connection)), callback(std::move(callbackFunc))
262 {}
263
getPathGetSensorConfiguration264 void getPath(const std::string& path, const std::string& interface,
265 const std::string& owner, size_t retries = 5)
266 {
267 if (retries > 5)
268 {
269 retries = 5;
270 }
271 std::shared_ptr<GetSensorConfiguration> self = shared_from_this();
272
273 self->dbusConnection->async_method_call(
274 [self, path, interface, owner, retries](
275 const boost::system::error_code ec, SensorBaseConfigMap& data) {
276 if (ec)
277 {
278 if (retries == 0U)
279 {
280 std::cerr << "Error getting " << path
281 << ": no retries left\n";
282 return;
283 }
284 std::cerr << "Error getting " << path << ": " << retries - 1
285 << " retries left\n";
286 auto timer = std::make_shared<boost::asio::steady_timer>(
287 self->dbusConnection->get_io_context());
288 timer->expires_after(std::chrono::seconds(10));
289 timer->async_wait([self, timer, path, interface, owner,
290 retries](boost::system::error_code ec) {
291 if (ec)
292 {
293 std::cerr << "Timer error!\n";
294 return;
295 }
296 self->getPath(path, interface, owner, retries - 1);
297 });
298 return;
299 }
300
301 self->respData[path][interface] = std::move(data);
302 },
303 owner, path, "org.freedesktop.DBus.Properties", "GetAll",
304 interface);
305 }
306
getConfigurationGetSensorConfiguration307 void getConfiguration(const std::vector<std::string>& types,
308 size_t retries = 0)
309 {
310 if (retries > 5)
311 {
312 retries = 5;
313 }
314
315 std::vector<std::string> interfaces(types.size());
316 for (const auto& type : types)
317 {
318 interfaces.push_back(configInterfaceName(type));
319 }
320
321 std::shared_ptr<GetSensorConfiguration> self = shared_from_this();
322 dbusConnection->async_method_call(
323 [self, interfaces, retries](const boost::system::error_code ec,
324 const GetSubTreeType& ret) {
325 if (ec)
326 {
327 std::cerr << "Error calling mapper\n";
328 if (retries == 0U)
329 {
330 return;
331 }
332 auto timer = std::make_shared<boost::asio::steady_timer>(
333 self->dbusConnection->get_io_context());
334 timer->expires_after(std::chrono::seconds(10));
335 timer->async_wait([self, timer, interfaces,
336 retries](boost::system::error_code ec) {
337 if (ec)
338 {
339 std::cerr << "Timer error!\n";
340 return;
341 }
342 self->getConfiguration(interfaces, retries - 1);
343 });
344
345 return;
346 }
347 for (const auto& [path, objDict] : ret)
348 {
349 if (objDict.empty())
350 {
351 return;
352 }
353 const std::string& owner = objDict.begin()->first;
354
355 for (const std::string& interface : objDict.begin()->second)
356 {
357 // anything that starts with a requested configuration
358 // is good
359 if (std::find_if(
360 interfaces.begin(), interfaces.end(),
361 [interface](const std::string& possible) {
362 return interface.starts_with(possible);
363 }) == interfaces.end())
364 {
365 continue;
366 }
367 self->getPath(path, interface, owner);
368 }
369 }
370 },
371 mapper::busName, mapper::path, mapper::interface, mapper::subtree,
372 "/", 0, interfaces);
373 }
374
~GetSensorConfigurationGetSensorConfiguration375 ~GetSensorConfiguration()
376 {
377 callback(respData);
378 }
379
380 std::shared_ptr<sdbusplus::asio::connection> dbusConnection;
381 std::function<void(ManagedObjectType& resp)> callback;
382 ManagedObjectType respData;
383 };
384
385 // The common scheme for sysfs files naming is: <type><number>_<item>.
386 // This function returns optionally these 3 elements as a tuple.
387 std::optional<std::tuple<std::string, std::string, std::string>> splitFileName(
388 const std::filesystem::path& filePath);
389 std::optional<double> readFile(const std::string& thresholdFile,
390 const double& scaleFactor);
391 void setupManufacturingModeMatch(sdbusplus::asio::connection& conn);
392 bool getManufacturingMode();
393 std::vector<std::unique_ptr<sdbusplus::bus::match_t>>
394 setupPropertiesChangedMatches(
395 sdbusplus::asio::connection& bus, std::span<const char* const> types,
396 const std::function<void(sdbusplus::message_t&)>& handler);
397
398 template <typename T>
getDeviceBusAddr(const std::string & deviceName,T & bus,T & addr)399 bool getDeviceBusAddr(const std::string& deviceName, T& bus, T& addr)
400 {
401 auto findHyphen = deviceName.find('-');
402 if (findHyphen == std::string::npos)
403 {
404 std::cerr << "found bad device " << deviceName << "\n";
405 return false;
406 }
407 std::string busStr = deviceName.substr(0, findHyphen);
408 std::string addrStr = deviceName.substr(findHyphen + 1);
409
410 std::from_chars_result res{};
411 res = std::from_chars(&*busStr.begin(), &*busStr.end(), bus);
412 if (res.ec != std::errc{} || res.ptr != &*busStr.end())
413 {
414 std::cerr << "Error finding bus for " << deviceName << "\n";
415 return false;
416 }
417 res = std::from_chars(&*addrStr.begin(), &*addrStr.end(), addr, 16);
418 if (res.ec != std::errc{} || res.ptr != &*addrStr.end())
419 {
420 std::cerr << "Error finding addr for " << deviceName << "\n";
421 return false;
422 }
423
424 return true;
425 }
426