James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 1 | #pragma once |
Andrew Jeffery | e73bd0a | 2023-01-25 10:39:57 +1030 | [diff] [blame] | 2 | |
| 3 | #include "VariantVisitors.hpp" |
| 4 | |
Zhikui Ren | da98f09 | 2021-11-01 09:41:08 -0700 | [diff] [blame] | 5 | #include <boost/algorithm/string/replace.hpp> |
James Feist | 8086aba | 2020-08-25 16:00:59 -0700 | [diff] [blame] | 6 | #include <boost/asio/steady_timer.hpp> |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 7 | #include <boost/container/flat_map.hpp> |
James Feist | 38fb598 | 2020-05-28 10:09:54 -0700 | [diff] [blame] | 8 | #include <sdbusplus/asio/connection.hpp> |
| 9 | #include <sdbusplus/asio/object_server.hpp> |
Ed Tanous | 18b6186 | 2025-01-30 10:56:28 -0800 | [diff] [blame] | 10 | #include <sdbusplus/bus/match.hpp> |
| 11 | #include <sdbusplus/message.hpp> |
| 12 | #include <sdbusplus/message/native_types.hpp> |
James Feist | 38fb598 | 2020-05-28 10:09:54 -0700 | [diff] [blame] | 13 | |
Ed Tanous | 18b6186 | 2025-01-30 10:56:28 -0800 | [diff] [blame] | 14 | #include <algorithm> |
| 15 | #include <charconv> |
| 16 | #include <chrono> |
| 17 | #include <cmath> |
| 18 | #include <cstddef> |
| 19 | #include <cstdint> |
James Feist | 24f02f2 | 2019-04-15 11:05:39 -0700 | [diff] [blame] | 20 | #include <filesystem> |
Patrick Venture | fd6ba73 | 2019-10-31 14:27:39 -0700 | [diff] [blame] | 21 | #include <functional> |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 22 | #include <iostream> |
Patrick Venture | fd6ba73 | 2019-10-31 14:27:39 -0700 | [diff] [blame] | 23 | #include <memory> |
Bruce Mitchell | 544e7dc | 2021-07-29 18:05:49 -0500 | [diff] [blame] | 24 | #include <optional> |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 25 | #include <regex> |
Ed Tanous | 18b6186 | 2025-01-30 10:56:28 -0800 | [diff] [blame] | 26 | #include <set> |
Zev Weiss | 214d971 | 2022-08-12 12:54:31 -0700 | [diff] [blame] | 27 | #include <span> |
Ed Tanous | 18b6186 | 2025-01-30 10:56:28 -0800 | [diff] [blame] | 28 | #include <stdexcept> |
Patrick Venture | fd6ba73 | 2019-10-31 14:27:39 -0700 | [diff] [blame] | 29 | #include <string> |
Ed Tanous | 18b6186 | 2025-01-30 10:56:28 -0800 | [diff] [blame] | 30 | #include <string_view> |
| 31 | #include <system_error> |
Patrick Venture | fd6ba73 | 2019-10-31 14:27:39 -0700 | [diff] [blame] | 32 | #include <tuple> |
| 33 | #include <utility> |
| 34 | #include <variant> |
| 35 | #include <vector> |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 36 | |
Jae Hyun Yoo | 9ced0a3 | 2018-10-25 10:42:39 -0700 | [diff] [blame] | 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"; |
James Feist | 58295ad | 2019-05-30 15:01:41 -0700 | [diff] [blame] | 40 | |
| 41 | constexpr const char* cpuInventoryPath = |
| 42 | "/xyz/openbmc_project/inventory/system/chassis/motherboard"; |
Jae Hyun Yoo | 9ced0a3 | 2018-10-25 10:42:39 -0700 | [diff] [blame] | 43 | const std::regex illegalDbusRegex("[^A-Za-z0-9_]"); |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 44 | |
| 45 | using BasicVariantType = |
James Feist | 3eb8262 | 2019-02-08 13:10:22 -0800 | [diff] [blame] | 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>; |
Alex Qiu | 8b3f7d4 | 2020-01-06 13:54:42 -0800 | [diff] [blame] | 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>; |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 54 | |
James Feist | a5e5872 | 2019-04-22 14:43:11 -0700 | [diff] [blame] | 55 | using GetSubTreeType = std::vector< |
| 56 | std::pair<std::string, |
| 57 | std::vector<std::pair<std::string, std::vector<std::string>>>>>; |
James Feist | d8bd562 | 2019-06-26 12:09:05 -0700 | [diff] [blame] | 58 | using Association = std::tuple<std::string, std::string, std::string>; |
| 59 | |
Zhikui Ren | da98f09 | 2021-11-01 09:41:08 -0700 | [diff] [blame] | 60 | inline std::string escapeName(const std::string& sensorName) |
| 61 | { |
| 62 | return boost::replace_all_copy(sensorName, " ", "_"); |
| 63 | } |
| 64 | |
Zev Weiss | 88cb29d | 2022-05-09 03:46:15 +0000 | [diff] [blame] | 65 | enum class PowerState |
| 66 | { |
| 67 | on, |
| 68 | biosPost, |
Thu Nguyen | 6db8aae | 2022-10-04 08:12:48 +0700 | [diff] [blame] | 69 | always, |
| 70 | chassisOn |
Zev Weiss | 88cb29d | 2022-05-09 03:46:15 +0000 | [diff] [blame] | 71 | }; |
| 72 | |
Jason Ling | 100c20b | 2020-08-11 14:50:33 -0700 | [diff] [blame] | 73 | std::optional<std::string> openAndRead(const std::string& hwmonFile); |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 74 | std::optional<std::string> getFullHwmonFilePath( |
| 75 | const std::string& directory, const std::string& hwmonBaseName, |
| 76 | const std::set<std::string>& permitSet); |
Jason Ling | 100c20b | 2020-08-11 14:50:33 -0700 | [diff] [blame] | 77 | std::set<std::string> getPermitSet(const SensorBaseConfigMap& config); |
Ed Tanous | 8a57ec0 | 2020-10-09 12:46:52 -0700 | [diff] [blame] | 78 | bool findFiles(const std::filesystem::path& dirPath, |
Lei YU | 6a4e973 | 2021-10-20 13:27:34 +0800 | [diff] [blame] | 79 | std::string_view matchString, |
James Feist | cf3bce6 | 2019-01-08 10:07:19 -0800 | [diff] [blame] | 80 | std::vector<std::filesystem::path>& foundPaths, |
Ed Tanous | 8a57ec0 | 2020-10-09 12:46:52 -0700 | [diff] [blame] | 81 | int symlinkDepth = 1); |
Ed Tanous | 201a101 | 2024-04-03 18:07:28 -0700 | [diff] [blame] | 82 | bool isPowerOn(); |
| 83 | bool hasBiosPost(); |
| 84 | bool isChassisOn(); |
Zev Weiss | 88cb29d | 2022-05-09 03:46:15 +0000 | [diff] [blame] | 85 | void setupPowerMatchCallback( |
| 86 | const std::shared_ptr<sdbusplus::asio::connection>& conn, |
| 87 | std::function<void(PowerState type, bool state)>&& callback); |
James Feist | 71d31b2 | 2019-01-02 16:57:54 -0800 | [diff] [blame] | 88 | void setupPowerMatch(const std::shared_ptr<sdbusplus::asio::connection>& conn); |
James Feist | 6714a25 | 2018-09-10 15:26:18 -0700 | [diff] [blame] | 89 | bool getSensorConfiguration( |
| 90 | const std::string& type, |
| 91 | const std::shared_ptr<sdbusplus::asio::connection>& dbusConnection, |
Ed Tanous | 8a57ec0 | 2020-10-09 12:46:52 -0700 | [diff] [blame] | 92 | ManagedObjectType& resp, bool useCache); |
| 93 | |
James Feist | 82bac4c | 2019-03-11 11:16:53 -0700 | [diff] [blame] | 94 | void createAssociation( |
| 95 | std::shared_ptr<sdbusplus::asio::dbus_interface>& association, |
| 96 | const std::string& path); |
| 97 | |
James Feist | 87d713a | 2018-12-06 16:06:24 -0800 | [diff] [blame] | 98 | // replaces limits if MinReading and MaxReading are found. |
| 99 | void findLimits(std::pair<double, double>& limits, |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 100 | const SensorBaseConfiguration* data); |
| 101 | |
Konstantin Aladyshev | c7a1ae6 | 2021-04-30 08:50:43 +0000 | [diff] [blame] | 102 | bool readingStateGood(const PowerState& powerState); |
| 103 | |
Zev Weiss | 054aad8 | 2022-08-18 01:37:34 -0700 | [diff] [blame] | 104 | constexpr const char* configInterfacePrefix = |
| 105 | "xyz.openbmc_project.Configuration."; |
| 106 | |
| 107 | inline std::string configInterfaceName(const std::string& type) |
| 108 | { |
| 109 | return std::string(configInterfacePrefix) + type; |
| 110 | } |
| 111 | |
James Feist | a5e5872 | 2019-04-22 14:43:11 -0700 | [diff] [blame] | 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"; |
James Feist | 49a8ccd | 2020-09-16 16:09:52 -0700 | [diff] [blame] | 124 | constexpr const char* set = "Set"; |
James Feist | a5e5872 | 2019-04-22 14:43:11 -0700 | [diff] [blame] | 125 | } // namespace properties |
| 126 | |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 127 | namespace power |
| 128 | { |
Potin Lai | ef85e0b | 2024-02-23 10:30:19 +0800 | [diff] [blame] | 129 | const static constexpr char* busname = "xyz.openbmc_project.State.Host0"; |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 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 |
Thu Nguyen | 6db8aae | 2022-10-04 08:12:48 +0700 | [diff] [blame] | 134 | |
| 135 | namespace chassis |
| 136 | { |
Patrick Williams | ea14f14 | 2024-01-19 14:23:54 -0600 | [diff] [blame] | 137 | const static constexpr char* busname = "xyz.openbmc_project.State.Chassis0"; |
Thu Nguyen | 6db8aae | 2022-10-04 08:12:48 +0700 | [diff] [blame] | 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"; |
Thang Tran | 819eb32 | 2023-11-07 13:50:18 +0700 | [diff] [blame] | 141 | const static constexpr char* sOn = ".On"; |
Thu Nguyen | 6db8aae | 2022-10-04 08:12:48 +0700 | [diff] [blame] | 142 | } // namespace chassis |
| 143 | |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 144 | namespace post |
| 145 | { |
Potin Lai | ef85e0b | 2024-02-23 10:30:19 +0800 | [diff] [blame] | 146 | const static constexpr char* busname = "xyz.openbmc_project.State.Host0"; |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 147 | const static constexpr char* interface = |
| 148 | "xyz.openbmc_project.State.OperatingSystem.Status"; |
Potin Lai | ef85e0b | 2024-02-23 10:30:19 +0800 | [diff] [blame] | 149 | const static constexpr char* path = "/xyz/openbmc_project/state/host0"; |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 150 | const static constexpr char* property = "OperatingSystemState"; |
| 151 | } // namespace post |
| 152 | |
James Feist | 2adc95c | 2019-09-30 14:55:28 -0700 | [diff] [blame] | 153 | namespace association |
| 154 | { |
| 155 | const static constexpr char* interface = |
| 156 | "xyz.openbmc_project.Association.Definitions"; |
| 157 | } // namespace association |
| 158 | |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 159 | template <typename T> |
Zev Weiss | afd1504 | 2022-07-18 12:28:40 -0700 | [diff] [blame] | 160 | inline T loadVariant(const SensorBaseConfigMap& data, const std::string& key) |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 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 | { |
James Feist | 3eb8262 | 2019-02-08 13:10:22 -0800 | [diff] [blame] | 170 | return std::visit(VariantToDoubleVisitor(), it->second); |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 171 | } |
James Feist | 6ef2040 | 2019-01-07 16:45:08 -0800 | [diff] [blame] | 172 | else if constexpr (std::is_unsigned_v<T>) |
| 173 | { |
James Feist | 3eb8262 | 2019-02-08 13:10:22 -0800 | [diff] [blame] | 174 | return std::visit(VariantToUnsignedIntVisitor(), it->second); |
James Feist | 6ef2040 | 2019-01-07 16:45:08 -0800 | [diff] [blame] | 175 | } |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 176 | else if constexpr (std::is_same_v<T, std::string>) |
| 177 | { |
James Feist | 3eb8262 | 2019-02-08 13:10:22 -0800 | [diff] [blame] | 178 | return std::visit(VariantToStringVisitor(), it->second); |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 179 | } |
| 180 | else |
| 181 | { |
James Feist | 52497fd | 2019-06-07 13:01:33 -0700 | [diff] [blame] | 182 | static_assert(!std::is_same_v<T, T>, "Type Not Implemented"); |
James Feist | 40a7214 | 2018-12-21 10:09:53 -0800 | [diff] [blame] | 183 | } |
| 184 | } |
James Feist | fc94b21 | 2019-02-06 16:14:51 -0800 | [diff] [blame] | 185 | |
| 186 | inline void setReadState(const std::string& str, PowerState& val) |
| 187 | { |
James Feist | fc94b21 | 2019-02-06 16:14:51 -0800 | [diff] [blame] | 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 | } |
Thu Nguyen | 6db8aae | 2022-10-04 08:12:48 +0700 | [diff] [blame] | 200 | else if (str == "ChassisOn") |
| 201 | { |
| 202 | val = PowerState::chassisOn; |
| 203 | } |
James Feist | fc94b21 | 2019-02-06 16:14:51 -0800 | [diff] [blame] | 204 | } |
Cheng C Yang | 5580f2f | 2019-09-19 09:01:47 +0800 | [diff] [blame] | 205 | |
Zev Weiss | a4d2768 | 2022-07-19 15:30:36 -0700 | [diff] [blame] | 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 | { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 212 | std::string powerState = |
| 213 | std::visit(VariantToStringVisitor(), findPowerState->second); |
Zev Weiss | a4d2768 | 2022-07-19 15:30:36 -0700 | [diff] [blame] | 214 | setReadState(powerState, state); |
| 215 | } |
| 216 | return state; |
| 217 | } |
| 218 | |
Zev Weiss | 8569bf2 | 2022-10-11 15:37:44 -0700 | [diff] [blame] | 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 | |
Ed Tanous | 8a57ec0 | 2020-10-09 12:46:52 -0700 | [diff] [blame] | 234 | inline void setLed(const std::shared_ptr<sdbusplus::asio::connection>& conn, |
James Feist | 49a8ccd | 2020-09-16 16:09:52 -0700 | [diff] [blame] | 235 | const std::string& name, bool on) |
| 236 | { |
| 237 | conn->async_method_call( |
| 238 | [name](const boost::system::error_code ec) { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 239 | if (ec) |
| 240 | { |
| 241 | std::cerr << "Failed to set LED " << name << "\n"; |
| 242 | } |
| 243 | }, |
James Feist | 49a8ccd | 2020-09-16 16:09:52 -0700 | [diff] [blame] | 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 | |
Cheng C Yang | 5580f2f | 2019-09-19 09:01:47 +0800 | [diff] [blame] | 250 | void createInventoryAssoc( |
Ed Tanous | 8a57ec0 | 2020-10-09 12:46:52 -0700 | [diff] [blame] | 251 | const std::shared_ptr<sdbusplus::asio::connection>& conn, |
| 252 | const std::shared_ptr<sdbusplus::asio::dbus_interface>& association, |
Cheng C Yang | 5580f2f | 2019-09-19 09:01:47 +0800 | [diff] [blame] | 253 | const std::string& path); |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 254 | |
James Feist | 38fb598 | 2020-05-28 10:09:54 -0700 | [diff] [blame] | 255 | struct GetSensorConfiguration : |
| 256 | std::enable_shared_from_this<GetSensorConfiguration> |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 257 | { |
| 258 | GetSensorConfiguration( |
| 259 | std::shared_ptr<sdbusplus::asio::connection> connection, |
| 260 | std::function<void(ManagedObjectType& resp)>&& callbackFunc) : |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 261 | dbusConnection(std::move(connection)), callback(std::move(callbackFunc)) |
James Feist | 38fb598 | 2020-05-28 10:09:54 -0700 | [diff] [blame] | 262 | {} |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 263 | |
| 264 | void getPath(const std::string& path, const std::string& interface, |
| 265 | const std::string& owner, size_t retries = 5) |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 266 | { |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 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( |
Zev Weiss | afd1504 | 2022-07-18 12:28:40 -0700 | [diff] [blame] | 274 | [self, path, interface, owner, retries]( |
| 275 | const boost::system::error_code ec, SensorBaseConfigMap& data) { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 276 | if (ec) |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 277 | { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 278 | if (retries == 0U) |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 279 | { |
Patrick Rudolph | 291c295 | 2025-01-14 13:49:32 +0100 | [diff] [blame] | 280 | std::cerr << "Error getting " << path |
| 281 | << ": no retries left\n"; |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 282 | return; |
| 283 | } |
Patrick Rudolph | 291c295 | 2025-01-14 13:49:32 +0100 | [diff] [blame] | 284 | std::cerr << "Error getting " << path << ": " << retries - 1 |
| 285 | << " retries left\n"; |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 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 | } |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 300 | |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 301 | self->respData[path][interface] = std::move(data); |
| 302 | }, |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 303 | owner, path, "org.freedesktop.DBus.Properties", "GetAll", |
| 304 | interface); |
| 305 | } |
| 306 | |
Zev Weiss | 054aad8 | 2022-08-18 01:37:34 -0700 | [diff] [blame] | 307 | void getConfiguration(const std::vector<std::string>& types, |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 308 | size_t retries = 0) |
| 309 | { |
| 310 | if (retries > 5) |
| 311 | { |
| 312 | retries = 5; |
| 313 | } |
| 314 | |
Zev Weiss | 054aad8 | 2022-08-18 01:37:34 -0700 | [diff] [blame] | 315 | std::vector<std::string> interfaces(types.size()); |
| 316 | for (const auto& type : types) |
| 317 | { |
| 318 | interfaces.push_back(configInterfaceName(type)); |
| 319 | } |
| 320 | |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 321 | std::shared_ptr<GetSensorConfiguration> self = shared_from_this(); |
| 322 | dbusConnection->async_method_call( |
James Feist | f27a55c | 2020-08-04 14:27:30 -0700 | [diff] [blame] | 323 | [self, interfaces, retries](const boost::system::error_code ec, |
| 324 | const GetSubTreeType& ret) { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 325 | if (ec) |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 326 | { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 327 | std::cerr << "Error calling mapper\n"; |
| 328 | if (retries == 0U) |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 329 | { |
| 330 | return; |
| 331 | } |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 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 | }); |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 344 | |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 345 | return; |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 346 | } |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 347 | for (const auto& [path, objDict] : ret) |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 348 | { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 349 | if (objDict.empty()) |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 350 | { |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 351 | return; |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 352 | } |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 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 | } |
Ed Tanous | bb67932 | 2022-05-16 16:10:00 -0700 | [diff] [blame] | 369 | } |
Patrick Williams | 2aaf717 | 2024-08-16 15:20:40 -0400 | [diff] [blame] | 370 | }, |
James Feist | c71c119 | 2019-09-18 14:31:33 -0700 | [diff] [blame] | 371 | mapper::busName, mapper::path, mapper::interface, mapper::subtree, |
| 372 | "/", 0, interfaces); |
| 373 | } |
| 374 | |
| 375 | ~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 | }; |
Zbigniew Kurzynski | 63f3866 | 2020-06-09 13:02:11 +0200 | [diff] [blame] | 384 | |
| 385 | // The common scheme for sysfs files naming is: <type><number>_<item>. |
| 386 | // This function returns optionally these 3 elements as a tuple. |
Patrick Williams | 556e04b | 2025-02-01 08:22:22 -0500 | [diff] [blame] | 387 | std::optional<std::tuple<std::string, std::string, std::string>> splitFileName( |
| 388 | const std::filesystem::path& filePath); |
Zbigniew Kurzynski | 63f3866 | 2020-06-09 13:02:11 +0200 | [diff] [blame] | 389 | std::optional<double> readFile(const std::string& thresholdFile, |
James Feist | 8086aba | 2020-08-25 16:00:59 -0700 | [diff] [blame] | 390 | const double& scaleFactor); |
Bruce Lee | 1263c3d | 2021-06-04 15:16:33 +0800 | [diff] [blame] | 391 | void setupManufacturingModeMatch(sdbusplus::asio::connection& conn); |
| 392 | bool getManufacturingMode(); |
Zev Weiss | 214d971 | 2022-08-12 12:54:31 -0700 | [diff] [blame] | 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); |
Tom Tung | 278e177 | 2023-12-12 09:20:40 +0800 | [diff] [blame] | 397 | |
| 398 | template <typename T> |
| 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 | } |