blob: 4665f384d486eb6a39b3818841b5b83432b6f211 [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
161GetSensorResponse assertion(const Info& sensorInfo)
162{
Patrick Venture0b02be92018-08-31 11:55:55 -0700163 return mapDbusToAssertion(sensorInfo, sensorInfo.sensorPath,
Tom Joseph816e92b2017-09-06 19:23:00 +0530164 sensorInfo.sensorInterface);
165}
166
Tom Josephe4014fc2017-09-06 23:57:36 +0530167GetSensorResponse eventdata2(const Info& sensorInfo)
168{
169 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Patrick Venture0b02be92018-08-31 11:55:55 -0700170 GetSensorResponse response{};
Tom Josephe4014fc2017-09-06 23:57:36 +0530171
Jeremy Kerr3dc35582020-05-17 15:47:07 +0800172 enableScanning(&response);
173
Patrick Venture0b02be92018-08-31 11:55:55 -0700174 auto service = ipmi::getService(bus, sensorInfo.sensorInterface,
Tom Josephe4014fc2017-09-06 23:57:36 +0530175 sensorInfo.sensorPath);
176
177 const auto& interfaceList = sensorInfo.propertyInterfaces;
178
179 for (const auto& interface : interfaceList)
180 {
181 for (const auto& property : interface.second)
182 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700183 auto propValue =
184 ipmi::getDbusProperty(bus, service, sensorInfo.sensorPath,
185 interface.first, property.first);
Tom Josephe4014fc2017-09-06 23:57:36 +0530186
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500187 for (const auto& value : std::get<OffsetValueMap>(property.second))
Tom Josephe4014fc2017-09-06 23:57:36 +0530188 {
189 if (propValue == value.second.assert)
190 {
Sui Chen4cc42552019-09-11 10:28:35 -0700191 setReading(value.first, &response);
Tom Josephe4014fc2017-09-06 23:57:36 +0530192 break;
193 }
194 }
195 }
196 }
197
198 return response;
199}
200
Patrick Venture0b02be92018-08-31 11:55:55 -0700201} // namespace get
Tom Joseph816e92b2017-09-06 19:23:00 +0530202
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500203namespace set
204{
205
206IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
207 const std::string& sensorPath,
208 const std::string& command,
209 const std::string& sensorInterface)
210{
211 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
212 using namespace std::string_literals;
213
Patrick Venture0b02be92018-08-31 11:55:55 -0700214 auto dbusService = getService(bus, sensorInterface, sensorPath);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500215
Patrick Venture0b02be92018-08-31 11:55:55 -0700216 return bus.new_method_call(dbusService.c_str(), sensorPath.c_str(),
217 updateInterface.c_str(), command.c_str());
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500218}
219
Patrick Venture0b02be92018-08-31 11:55:55 -0700220ipmi_ret_t eventdata(const SetSensorReadingReq& cmdData, const Info& sensorInfo,
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500221 uint8_t data)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500222{
Patrick Venture0b02be92018-08-31 11:55:55 -0700223 auto msg =
224 makeDbusMsg("org.freedesktop.DBus.Properties", sensorInfo.sensorPath,
225 "Set", sensorInfo.sensorInterface);
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500226
227 const auto& interface = sensorInfo.propertyInterfaces.begin();
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500228 msg.append(interface->first);
229 for (const auto& property : interface->second)
230 {
231 msg.append(property.first);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500232 const auto& iter = std::get<OffsetValueMap>(property.second).find(data);
233 if (iter == std::get<OffsetValueMap>(property.second).end())
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500234 {
235 log<level::ERR>("Invalid event data");
236 return IPMI_CC_PARM_OUT_OF_RANGE;
237 }
238 msg.append(iter->second.assert);
239 }
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500240 return updateToDbus(msg);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500241}
242
Patrick Venture0b02be92018-08-31 11:55:55 -0700243ipmi_ret_t assertion(const SetSensorReadingReq& cmdData, const Info& sensorInfo)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500244{
Brad Bishop06a0abf2018-02-26 20:46:00 -0500245 std::bitset<16> assertionSet(getAssertionSet(cmdData).first);
246 std::bitset<16> deassertionSet(getAssertionSet(cmdData).second);
247 auto bothSet = assertionSet ^ deassertionSet;
248
249 const auto& interface = sensorInfo.propertyInterfaces.begin();
250
251 for (const auto& property : interface->second)
252 {
William A. Kennington III4c008022018-10-12 17:18:14 -0700253 std::optional<Value> tmp;
Brad Bishop06a0abf2018-02-26 20:46:00 -0500254 for (const auto& value : std::get<OffsetValueMap>(property.second))
255 {
256 if (bothSet.size() <= value.first || !bothSet.test(value.first))
257 {
258 // A BIOS shouldn't do this but ignore if they do.
259 continue;
260 }
261
262 if (assertionSet.test(value.first))
263 {
264 tmp = value.second.assert;
265 break;
266 }
267 if (deassertionSet.test(value.first))
268 {
269 tmp = value.second.deassert;
270 break;
271 }
272 }
273
William A. Kennington III4c008022018-10-12 17:18:14 -0700274 if (tmp)
Brad Bishop06a0abf2018-02-26 20:46:00 -0500275 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700276 auto msg = makeDbusMsg("org.freedesktop.DBus.Properties",
277 sensorInfo.sensorPath, "Set",
278 sensorInfo.sensorInterface);
Brad Bishop06a0abf2018-02-26 20:46:00 -0500279 msg.append(interface->first);
280 msg.append(property.first);
William A. Kennington III4c008022018-10-12 17:18:14 -0700281 msg.append(*tmp);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500282
Brad Bishop06a0abf2018-02-26 20:46:00 -0500283 auto rc = updateToDbus(msg);
284 if (rc)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500285 {
Brad Bishop06a0abf2018-02-26 20:46:00 -0500286 return rc;
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500287 }
288 }
289 }
Brad Bishop06a0abf2018-02-26 20:46:00 -0500290
291 return IPMI_CC_OK;
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500292}
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500293
Patrick Venture0b02be92018-08-31 11:55:55 -0700294} // namespace set
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500295
296namespace notify
297{
298
299IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
300 const std::string& sensorPath,
301 const std::string& command,
302 const std::string& sensorInterface)
303{
304 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
305 using namespace std::string_literals;
306
Dhruvaraj Subhashchandranf915f852017-09-14 07:01:48 -0500307 static const auto dbusPath = "/xyz/openbmc_project/inventory"s;
308 std::string dbusService = ipmi::getService(bus, updateInterface, dbusPath);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500309
Patrick Venture0b02be92018-08-31 11:55:55 -0700310 return bus.new_method_call(dbusService.c_str(), dbusPath.c_str(),
311 updateInterface.c_str(), command.c_str());
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500312}
313
Patrick Venture0b02be92018-08-31 11:55:55 -0700314ipmi_ret_t assertion(const SetSensorReadingReq& cmdData, const Info& sensorInfo)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500315{
Patrick Venture0b02be92018-08-31 11:55:55 -0700316 auto msg = makeDbusMsg(sensorInfo.sensorInterface, sensorInfo.sensorPath,
317 "Notify", sensorInfo.sensorInterface);
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500318
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500319 std::bitset<16> assertionSet(getAssertionSet(cmdData).first);
320 std::bitset<16> deassertionSet(getAssertionSet(cmdData).second);
321 ipmi::sensor::ObjectMap objects;
322 ipmi::sensor::InterfaceMap interfaces;
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500323 for (const auto& interface : sensorInfo.propertyInterfaces)
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500324 {
Santosh Puranikbbf8bd62019-05-01 19:02:52 +0530325 // An interface with no properties - It is possible that the sensor
326 // object on DBUS implements a DBUS interface with no properties.
327 // Make sure we add the interface to the list if interfaces on the
328 // object with an empty property map.
329 if (interface.second.empty())
330 {
331 interfaces.emplace(interface.first, ipmi::sensor::PropertyMap{});
332 continue;
333 }
Patrick Venture0b02be92018-08-31 11:55:55 -0700334 // For a property like functional state the result will be
335 // calculated based on the true value of all conditions.
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500336 for (const auto& property : interface.second)
337 {
338 ipmi::sensor::PropertyMap props;
339 bool valid = false;
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500340 auto result = true;
341 for (const auto& value : std::get<OffsetValueMap>(property.second))
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500342 {
343 if (assertionSet.test(value.first))
344 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700345 // Skip update if skipOn is ASSERT
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500346 if (SkipAssertion::ASSERT == value.second.skip)
347 {
348 return IPMI_CC_OK;
349 }
Vernon Maueryf442e112019-04-09 11:44:36 -0700350 result = result && std::get<bool>(value.second.assert);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500351 valid = true;
352 }
353 else if (deassertionSet.test(value.first))
354 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700355 // Skip update if skipOn is DEASSERT
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500356 if (SkipAssertion::DEASSERT == value.second.skip)
357 {
358 return IPMI_CC_OK;
359 }
Vernon Maueryf442e112019-04-09 11:44:36 -0700360 result = result && std::get<bool>(value.second.deassert);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500361 valid = true;
362 }
363 }
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500364 for (const auto& value :
Patrick Venture0b02be92018-08-31 11:55:55 -0700365 std::get<PreReqOffsetValueMap>(property.second))
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500366 {
367 if (assertionSet.test(value.first))
368 {
Vernon Maueryf442e112019-04-09 11:44:36 -0700369 result = result && std::get<bool>(value.second.assert);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500370 }
371 else if (deassertionSet.test(value.first))
372 {
Vernon Maueryf442e112019-04-09 11:44:36 -0700373 result = result && std::get<bool>(value.second.deassert);
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500374 }
375 }
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500376 if (valid)
377 {
Dhruvaraj Subhashchandrane245e4e2017-10-03 03:58:05 -0500378 props.emplace(property.first, result);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500379 interfaces.emplace(interface.first, std::move(props));
380 }
381 }
382 }
Dhruvaraj Subhashchandrane84841c2017-08-22 07:40:27 -0500383
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500384 objects.emplace(sensorInfo.sensorPath, std::move(interfaces));
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500385 msg.append(std::move(objects));
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500386 return updateToDbus(msg);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500387}
Tom Joseph816e92b2017-09-06 19:23:00 +0530388
Patrick Venture0b02be92018-08-31 11:55:55 -0700389} // namespace notify
Tom Joseph816e92b2017-09-06 19:23:00 +0530390
391namespace inventory
392{
393
394namespace get
395{
396
397GetSensorResponse assertion(const Info& sensorInfo)
398{
Vernon Mauery185b9f82018-07-20 10:52:36 -0700399 namespace fs = std::filesystem;
Tom Joseph816e92b2017-09-06 19:23:00 +0530400
401 fs::path path{ipmi::sensor::inventoryRoot};
402 path += sensorInfo.sensorPath;
403
404 return ipmi::sensor::get::mapDbusToAssertion(
Patrick Venture0b02be92018-08-31 11:55:55 -0700405 sensorInfo, path.string(),
406 sensorInfo.propertyInterfaces.begin()->first);
Tom Joseph816e92b2017-09-06 19:23:00 +0530407}
408
Patrick Venture0b02be92018-08-31 11:55:55 -0700409} // namespace get
Tom Joseph816e92b2017-09-06 19:23:00 +0530410
411} // namespace inventory
Patrick Venture0b02be92018-08-31 11:55:55 -0700412} // namespace sensor
413} // namespace ipmi