blob: 949b732b41c19958ae15875008957696dea342a9 [file] [log] [blame]
Patrick Venture3a5071a2018-09-12 13:27:42 -07001#include "sensordatahandler.hpp"
2
3#include "sensorhandler.hpp"
Patrick Venture3a5071a2018-09-12 13:27:42 -07004
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -05005#include <bitset>
Vernon Mauerybdda8002019-02-26 10:18:51 -08006#include <filesystem>
Vernon Mauery33250242019-03-12 16:49:26 -07007#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -07008#include <ipmid/utils.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -07009#include <optional>
William A. Kennington III4c008022018-10-12 17:18:14 -070010#include <sdbusplus/message/types.hpp>
Patrick Venture3a5071a2018-09-12 13:27:42 -070011#include <xyz/openbmc_project/Common/error.hpp>
12
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050013namespace ipmi
14{
15namespace sensor
16{
17
18using namespace phosphor::logging;
19using InternalFailure =
20 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
21
22static constexpr auto MAPPER_BUSNAME = "xyz.openbmc_project.ObjectMapper";
23static constexpr auto MAPPER_PATH = "/xyz/openbmc_project/object_mapper";
24static constexpr auto MAPPER_INTERFACE = "xyz.openbmc_project.ObjectMapper";
25
26/** @brief get the D-Bus service and service path
27 * @param[in] bus - The Dbus bus object
28 * @param[in] interface - interface to the service
29 * @param[in] path - interested path in the list of objects
30 * @return pair of service path and service
31 */
32ServicePath getServiceAndPath(sdbusplus::bus::bus& bus,
33 const std::string& interface,
34 const std::string& path)
35{
36 auto depth = 0;
Patrick Venture0b02be92018-08-31 11:55:55 -070037 auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
38 MAPPER_INTERFACE, "GetSubTree");
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050039 mapperCall.append("/");
40 mapperCall.append(depth);
41 mapperCall.append(std::vector<Interface>({interface}));
42
43 auto mapperResponseMsg = bus.call(mapperCall);
44 if (mapperResponseMsg.is_method_error())
45 {
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050046 log<level::ERR>("Mapper GetSubTree failed",
Joseph Reynolds510eb9c2018-05-30 11:51:28 -050047 entry("PATH=%s", path.c_str()),
48 entry("INTERFACE=%s", interface.c_str()));
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050049 elog<InternalFailure>();
50 }
51
52 MapperResponseType mapperResponse;
53 mapperResponseMsg.read(mapperResponse);
54 if (mapperResponse.empty())
55 {
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050056 log<level::ERR>("Invalid mapper response",
Joseph Reynolds510eb9c2018-05-30 11:51:28 -050057 entry("PATH=%s", path.c_str()),
58 entry("INTERFACE=%s", interface.c_str()));
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050059 elog<InternalFailure>();
60 }
61
62 if (path.empty())
63 {
Patrick Venture0b02be92018-08-31 11:55:55 -070064 // Get the first one if the path is not in list.
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050065 return std::make_pair(mapperResponse.begin()->first,
66 mapperResponse.begin()->second.begin()->first);
67 }
68 const auto& iter = mapperResponse.find(path);
69 if (iter == mapperResponse.end())
70 {
Gunnar Millsc9fa69e2018-04-08 16:35:25 -050071 log<level::ERR>("Couldn't find D-Bus path",
Joseph Reynolds510eb9c2018-05-30 11:51:28 -050072 entry("PATH=%s", path.c_str()),
73 entry("INTERFACE=%s", interface.c_str()));
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050074 elog<InternalFailure>();
75 }
76 return std::make_pair(iter->first, iter->second.begin()->first);
77}
78
79AssertionSet getAssertionSet(const SetSensorReadingReq& cmdData)
80{
81 Assertion assertionStates =
82 (static_cast<Assertion>(cmdData.assertOffset8_14)) << 8 |
83 cmdData.assertOffset0_7;
84 Deassertion deassertionStates =
85 (static_cast<Deassertion>(cmdData.deassertOffset8_14)) << 8 |
86 cmdData.deassertOffset0_7;
87 return std::make_pair(assertionStates, deassertionStates);
88}
89
90ipmi_ret_t updateToDbus(IpmiUpdateData& msg)
91{
92 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
93 try
94 {
95 auto serviceResponseMsg = bus.call(msg);
96 if (serviceResponseMsg.is_method_error())
97 {
98 log<level::ERR>("Error in D-Bus call");
99 return IPMI_CC_UNSPECIFIED_ERROR;
100 }
101 }
Patrick Williamsa2ad2da2021-10-06 12:21:46 -0500102 catch (const InternalFailure& e)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500103 {
104 commit<InternalFailure>();
105 return IPMI_CC_UNSPECIFIED_ERROR;
106 }
107 return IPMI_CC_OK;
108}
109
Tom Joseph816e92b2017-09-06 19:23:00 +0530110namespace get
111{
112
Tom Josephb0adbcd2018-01-24 11:51:29 +0530113SensorName nameParentLeaf(const Info& sensorInfo)
114{
115 const auto pos = sensorInfo.sensorPath.find_last_of('/');
116 const auto leaf = sensorInfo.sensorPath.substr(pos + 1);
117
118 const auto remaining = sensorInfo.sensorPath.substr(0, pos);
119
120 const auto parentPos = remaining.find_last_of('/');
121 auto parent = remaining.substr(parentPos + 1);
122
123 parent += "_" + leaf;
124 return parent;
125}
126
Tom Joseph816e92b2017-09-06 19:23:00 +0530127GetSensorResponse mapDbusToAssertion(const Info& sensorInfo,
128 const InstancePath& path,
129 const DbusInterface& interface)
130{
131 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Patrick Venture0b02be92018-08-31 11:55:55 -0700132 GetSensorResponse response{};
Tom Joseph816e92b2017-09-06 19:23:00 +0530133
Jeremy Kerr3dc35582020-05-17 15:47:07 +0800134 enableScanning(&response);
135
Tom Joseph816e92b2017-09-06 19:23:00 +0530136 auto service = ipmi::getService(bus, interface, path);
137
138 const auto& interfaceList = sensorInfo.propertyInterfaces;
139
140 for (const auto& interface : interfaceList)
141 {
142 for (const auto& property : interface.second)
143 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700144 auto propValue = ipmi::getDbusProperty(
145 bus, service, path, interface.first, property.first);
Tom Joseph816e92b2017-09-06 19:23:00 +0530146
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500147 for (const auto& value : std::get<OffsetValueMap>(property.second))
Tom Joseph816e92b2017-09-06 19:23:00 +0530148 {
149 if (propValue == value.second.assert)
150 {
Sui Chen4cc42552019-09-11 10:28:35 -0700151 setOffset(value.first, &response);
Tom Joseph816e92b2017-09-06 19:23:00 +0530152 break;
153 }
Tom Joseph816e92b2017-09-06 19:23:00 +0530154 }
155 }
156 }
157
158 return response;
159}
160
Lei YUa8dc09b2021-10-13 18:06:46 +0800161GetSensorResponse mapDbusToEventdata2(const Info& sensorInfo)
Tom Josephe4014fc2017-09-06 23:57:36 +0530162{
163 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Patrick Venture0b02be92018-08-31 11:55:55 -0700164 GetSensorResponse response{};
Tom Josephe4014fc2017-09-06 23:57:36 +0530165
Jeremy Kerr3dc35582020-05-17 15:47:07 +0800166 enableScanning(&response);
167
Patrick Venture0b02be92018-08-31 11:55:55 -0700168 auto service = ipmi::getService(bus, sensorInfo.sensorInterface,
Tom Josephe4014fc2017-09-06 23:57:36 +0530169 sensorInfo.sensorPath);
170
171 const auto& interfaceList = sensorInfo.propertyInterfaces;
172
173 for (const auto& interface : interfaceList)
174 {
175 for (const auto& property : interface.second)
176 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700177 auto propValue =
178 ipmi::getDbusProperty(bus, service, sensorInfo.sensorPath,
179 interface.first, property.first);
Tom Josephe4014fc2017-09-06 23:57:36 +0530180
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500181 for (const auto& value : std::get<OffsetValueMap>(property.second))
Tom Josephe4014fc2017-09-06 23:57:36 +0530182 {
183 if (propValue == value.second.assert)
184 {
Sui Chen4cc42552019-09-11 10:28:35 -0700185 setReading(value.first, &response);
Tom Josephe4014fc2017-09-06 23:57:36 +0530186 break;
187 }
188 }
189 }
190 }
191
192 return response;
193}
Lei YUa8dc09b2021-10-13 18:06:46 +0800194
195#ifndef FEATURE_SENSORS_CACHE
196GetSensorResponse assertion(const Info& sensorInfo)
197{
198 return mapDbusToAssertion(sensorInfo, sensorInfo.sensorPath,
199 sensorInfo.sensorInterface);
200}
201
202GetSensorResponse eventdata2(const Info& sensorInfo)
203{
204 return mapDbusToEventdata2(sensorInfo);
205}
Lei YU8c2c0482021-09-16 17:28:28 +0800206#else
207std::optional<GetSensorResponse> assertion(uint8_t id, const Info& sensorInfo,
Lei YU8e8152c2021-12-06 20:11:08 +0800208 const PropertyMap& /*properties*/)
Lei YU8c2c0482021-09-16 17:28:28 +0800209{
Lei YUef960c02021-10-13 17:54:59 +0800210 // The assertion may contain multiple properties
211 // So we have to get the properties from DBus anyway
212 auto response = mapDbusToAssertion(sensorInfo, sensorInfo.sensorPath,
213 sensorInfo.sensorInterface);
214
215 if (!sensorCacheMap[id].has_value())
216 {
217 sensorCacheMap[id] = SensorData{};
218 }
219 sensorCacheMap[id]->response = response;
220 return response;
Lei YU8c2c0482021-09-16 17:28:28 +0800221}
222
223std::optional<GetSensorResponse> eventdata2(uint8_t id, const Info& sensorInfo,
Lei YU8e8152c2021-12-06 20:11:08 +0800224 const PropertyMap& /*properties*/)
Lei YU8c2c0482021-09-16 17:28:28 +0800225{
Lei YUa8dc09b2021-10-13 18:06:46 +0800226 // The eventdata2 may contain multiple properties
227 // So we have to get the properties from DBus anyway
228 auto response = mapDbusToEventdata2(sensorInfo);
229
230 if (!sensorCacheMap[id].has_value())
231 {
232 sensorCacheMap[id] = SensorData{};
233 }
234 sensorCacheMap[id]->response = response;
235 return response;
Lei YU8c2c0482021-09-16 17:28:28 +0800236}
237
238#endif // FEATURE_SENSORS_CACHE
Tom Josephe4014fc2017-09-06 23:57:36 +0530239
Patrick Venture0b02be92018-08-31 11:55:55 -0700240} // namespace get
Tom Joseph816e92b2017-09-06 19:23:00 +0530241
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500242namespace set
243{
244
245IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
246 const std::string& sensorPath,
247 const std::string& command,
248 const std::string& sensorInterface)
249{
250 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
251 using namespace std::string_literals;
252
Patrick Venture0b02be92018-08-31 11:55:55 -0700253 auto dbusService = getService(bus, sensorInterface, sensorPath);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500254
Patrick Venture0b02be92018-08-31 11:55:55 -0700255 return bus.new_method_call(dbusService.c_str(), sensorPath.c_str(),
256 updateInterface.c_str(), command.c_str());
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500257}
258
Patrick Venture0b02be92018-08-31 11:55:55 -0700259ipmi_ret_t eventdata(const SetSensorReadingReq& cmdData, const Info& sensorInfo,
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500260 uint8_t data)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500261{
Patrick Venture0b02be92018-08-31 11:55:55 -0700262 auto msg =
263 makeDbusMsg("org.freedesktop.DBus.Properties", sensorInfo.sensorPath,
264 "Set", sensorInfo.sensorInterface);
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500265
266 const auto& interface = sensorInfo.propertyInterfaces.begin();
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500267 msg.append(interface->first);
268 for (const auto& property : interface->second)
269 {
270 msg.append(property.first);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500271 const auto& iter = std::get<OffsetValueMap>(property.second).find(data);
272 if (iter == std::get<OffsetValueMap>(property.second).end())
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500273 {
274 log<level::ERR>("Invalid event data");
275 return IPMI_CC_PARM_OUT_OF_RANGE;
276 }
277 msg.append(iter->second.assert);
278 }
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500279 return updateToDbus(msg);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500280}
281
Patrick Venture0b02be92018-08-31 11:55:55 -0700282ipmi_ret_t assertion(const SetSensorReadingReq& cmdData, const Info& sensorInfo)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500283{
Brad Bishop06a0abf2018-02-26 20:46:00 -0500284 std::bitset<16> assertionSet(getAssertionSet(cmdData).first);
285 std::bitset<16> deassertionSet(getAssertionSet(cmdData).second);
286 auto bothSet = assertionSet ^ deassertionSet;
287
288 const auto& interface = sensorInfo.propertyInterfaces.begin();
289
290 for (const auto& property : interface->second)
291 {
William A. Kennington III4c008022018-10-12 17:18:14 -0700292 std::optional<Value> tmp;
Brad Bishop06a0abf2018-02-26 20:46:00 -0500293 for (const auto& value : std::get<OffsetValueMap>(property.second))
294 {
295 if (bothSet.size() <= value.first || !bothSet.test(value.first))
296 {
297 // A BIOS shouldn't do this but ignore if they do.
298 continue;
299 }
300
301 if (assertionSet.test(value.first))
302 {
303 tmp = value.second.assert;
304 break;
305 }
306 if (deassertionSet.test(value.first))
307 {
308 tmp = value.second.deassert;
309 break;
310 }
311 }
312
William A. Kennington III4c008022018-10-12 17:18:14 -0700313 if (tmp)
Brad Bishop06a0abf2018-02-26 20:46:00 -0500314 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700315 auto msg = makeDbusMsg("org.freedesktop.DBus.Properties",
316 sensorInfo.sensorPath, "Set",
317 sensorInfo.sensorInterface);
Brad Bishop06a0abf2018-02-26 20:46:00 -0500318 msg.append(interface->first);
319 msg.append(property.first);
William A. Kennington III4c008022018-10-12 17:18:14 -0700320 msg.append(*tmp);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500321
Brad Bishop06a0abf2018-02-26 20:46:00 -0500322 auto rc = updateToDbus(msg);
323 if (rc)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500324 {
Brad Bishop06a0abf2018-02-26 20:46:00 -0500325 return rc;
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500326 }
327 }
328 }
Brad Bishop06a0abf2018-02-26 20:46:00 -0500329
330 return IPMI_CC_OK;
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500331}
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500332
Patrick Venture0b02be92018-08-31 11:55:55 -0700333} // namespace set
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500334
335namespace notify
336{
337
338IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
339 const std::string& sensorPath,
340 const std::string& command,
341 const std::string& sensorInterface)
342{
343 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
344 using namespace std::string_literals;
345
Dhruvaraj Subhashchandranf915f852017-09-14 07:01:48 -0500346 static const auto dbusPath = "/xyz/openbmc_project/inventory"s;
347 std::string dbusService = ipmi::getService(bus, updateInterface, dbusPath);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500348
Patrick Venture0b02be92018-08-31 11:55:55 -0700349 return bus.new_method_call(dbusService.c_str(), dbusPath.c_str(),
350 updateInterface.c_str(), command.c_str());
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500351}
352
Patrick Venture0b02be92018-08-31 11:55:55 -0700353ipmi_ret_t assertion(const SetSensorReadingReq& cmdData, const Info& sensorInfo)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500354{
Patrick Venture0b02be92018-08-31 11:55:55 -0700355 auto msg = makeDbusMsg(sensorInfo.sensorInterface, sensorInfo.sensorPath,
356 "Notify", sensorInfo.sensorInterface);
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500357
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500358 std::bitset<16> assertionSet(getAssertionSet(cmdData).first);
359 std::bitset<16> deassertionSet(getAssertionSet(cmdData).second);
360 ipmi::sensor::ObjectMap objects;
361 ipmi::sensor::InterfaceMap interfaces;
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500362 for (const auto& interface : sensorInfo.propertyInterfaces)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500363 {
Santosh Puranikbbf8bd62019-05-01 19:02:52 +0530364 // An interface with no properties - It is possible that the sensor
365 // object on DBUS implements a DBUS interface with no properties.
366 // Make sure we add the interface to the list if interfaces on the
367 // object with an empty property map.
368 if (interface.second.empty())
369 {
370 interfaces.emplace(interface.first, ipmi::sensor::PropertyMap{});
371 continue;
372 }
Patrick Venture0b02be92018-08-31 11:55:55 -0700373 // For a property like functional state the result will be
374 // calculated based on the true value of all conditions.
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500375 for (const auto& property : interface.second)
376 {
377 ipmi::sensor::PropertyMap props;
378 bool valid = false;
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500379 auto result = true;
380 for (const auto& value : std::get<OffsetValueMap>(property.second))
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500381 {
382 if (assertionSet.test(value.first))
383 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700384 // Skip update if skipOn is ASSERT
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500385 if (SkipAssertion::ASSERT == value.second.skip)
386 {
387 return IPMI_CC_OK;
388 }
Vernon Maueryf442e112019-04-09 11:44:36 -0700389 result = result && std::get<bool>(value.second.assert);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500390 valid = true;
391 }
392 else if (deassertionSet.test(value.first))
393 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700394 // Skip update if skipOn is DEASSERT
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500395 if (SkipAssertion::DEASSERT == value.second.skip)
396 {
397 return IPMI_CC_OK;
398 }
Vernon Maueryf442e112019-04-09 11:44:36 -0700399 result = result && std::get<bool>(value.second.deassert);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500400 valid = true;
401 }
402 }
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500403 for (const auto& value :
Patrick Venture0b02be92018-08-31 11:55:55 -0700404 std::get<PreReqOffsetValueMap>(property.second))
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500405 {
406 if (assertionSet.test(value.first))
407 {
Vernon Maueryf442e112019-04-09 11:44:36 -0700408 result = result && std::get<bool>(value.second.assert);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500409 }
410 else if (deassertionSet.test(value.first))
411 {
Vernon Maueryf442e112019-04-09 11:44:36 -0700412 result = result && std::get<bool>(value.second.deassert);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500413 }
414 }
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500415 if (valid)
416 {
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500417 props.emplace(property.first, result);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500418 interfaces.emplace(interface.first, std::move(props));
419 }
420 }
421 }
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500422
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500423 objects.emplace(sensorInfo.sensorPath, std::move(interfaces));
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500424 msg.append(std::move(objects));
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500425 return updateToDbus(msg);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500426}
Tom Joseph816e92b2017-09-06 19:23:00 +0530427
Patrick Venture0b02be92018-08-31 11:55:55 -0700428} // namespace notify
Tom Joseph816e92b2017-09-06 19:23:00 +0530429
430namespace inventory
431{
432
433namespace get
434{
435
Lei YUff8c9b42021-10-15 14:20:57 +0800436#ifndef FEATURE_SENSORS_CACHE
437
Tom Joseph816e92b2017-09-06 19:23:00 +0530438GetSensorResponse assertion(const Info& sensorInfo)
439{
Vernon Mauery185b9f82018-07-20 10:52:36 -0700440 namespace fs = std::filesystem;
Tom Joseph816e92b2017-09-06 19:23:00 +0530441
442 fs::path path{ipmi::sensor::inventoryRoot};
443 path += sensorInfo.sensorPath;
444
445 return ipmi::sensor::get::mapDbusToAssertion(
Patrick Venture0b02be92018-08-31 11:55:55 -0700446 sensorInfo, path.string(),
447 sensorInfo.propertyInterfaces.begin()->first);
Tom Joseph816e92b2017-09-06 19:23:00 +0530448}
449
Lei YUff8c9b42021-10-15 14:20:57 +0800450#else
451
452std::optional<GetSensorResponse> assertion(uint8_t id, const Info& sensorInfo,
Lei YU8e8152c2021-12-06 20:11:08 +0800453 const PropertyMap& /*properties*/)
Lei YUff8c9b42021-10-15 14:20:57 +0800454{
Lei YUff8c9b42021-10-15 14:20:57 +0800455 // The assertion may contain multiple properties
456 // So we have to get the properties from DBus anyway
457 namespace fs = std::filesystem;
458
459 fs::path path{ipmi::sensor::inventoryRoot};
460 path += sensorInfo.sensorPath;
461
462 auto response = ipmi::sensor::get::mapDbusToAssertion(
463 sensorInfo, path.string(),
464 sensorInfo.propertyInterfaces.begin()->first);
465
466 if (!sensorCacheMap[id].has_value())
467 {
468 sensorCacheMap[id] = SensorData{};
469 }
470 sensorCacheMap[id]->response = response;
471 return response;
472}
473
474#endif
475
Patrick Venture0b02be92018-08-31 11:55:55 -0700476} // namespace get
Tom Joseph816e92b2017-09-06 19:23:00 +0530477
478} // namespace inventory
Patrick Venture0b02be92018-08-31 11:55:55 -0700479} // namespace sensor
480} // namespace ipmi