1 #include "config.h"
2
3 #include "sensorhandler.hpp"
4
5 #include "fruread.hpp"
6
7 #include <systemd/sd-bus.h>
8
9 #include <ipmid/api.hpp>
10 #include <ipmid/entity_map_json.hpp>
11 #include <ipmid/types.hpp>
12 #include <ipmid/utils.hpp>
13 #include <phosphor-logging/elog-errors.hpp>
14 #include <phosphor-logging/lg2.hpp>
15 #include <sdbusplus/message/types.hpp>
16 #include <xyz/openbmc_project/Common/error.hpp>
17 #include <xyz/openbmc_project/Sensor/Value/server.hpp>
18
19 #include <bitset>
20 #include <cmath>
21 #include <cstring>
22 #include <set>
23
24 static constexpr uint8_t fruInventoryDevice = 0x10;
25 static constexpr uint8_t IPMIFruInventory = 0x02;
26 static constexpr uint8_t BMCTargetAddress = 0x20;
27
28 extern int updateSensorRecordFromSSRAESC(const void*);
29 extern sd_bus* bus;
30
31 namespace ipmi
32 {
33 namespace sensor
34 {
35 extern const IdInfoMap sensors;
36 } // namespace sensor
37 } // namespace ipmi
38
39 extern const FruMap frus;
40
41 using namespace phosphor::logging;
42 using InternalFailure =
43 sdbusplus::error::xyz::openbmc_project::common::InternalFailure;
44
45 void register_netfn_sen_functions() __attribute__((constructor));
46
47 struct sensorTypemap_t
48 {
49 uint8_t number;
50 uint8_t typecode;
51 char dbusname[32];
52 };
53
54 sensorTypemap_t g_SensorTypeMap[] = {
55
56 {0x01, 0x6F, "Temp"},
57 {0x0C, 0x6F, "DIMM"},
58 {0x0C, 0x6F, "MEMORY_BUFFER"},
59 {0x07, 0x6F, "PROC"},
60 {0x07, 0x6F, "CORE"},
61 {0x07, 0x6F, "CPU"},
62 {0x0F, 0x6F, "BootProgress"},
63 {0xe9, 0x09, "OccStatus"}, // E9 is an internal mapping to handle sensor
64 // type code os 0x09
65 {0xC3, 0x6F, "BootCount"},
66 {0x1F, 0x6F, "OperatingSystemStatus"},
67 {0x12, 0x6F, "SYSTEM_EVENT"},
68 {0xC7, 0x03, "SYSTEM"},
69 {0xC7, 0x03, "MAIN_PLANAR"},
70 {0xC2, 0x6F, "PowerCap"},
71 {0x0b, 0xCA, "PowerSupplyRedundancy"},
72 {0xDA, 0x03, "TurboAllowed"},
73 {0xD8, 0xC8, "PowerSupplyDerating"},
74 {0xFF, 0x00, ""},
75 };
76
77 struct sensor_data_t
78 {
79 uint8_t sennum;
80 } __attribute__((packed));
81
82 using SDRCacheMap = std::unordered_map<uint8_t, get_sdr::SensorDataFullRecord>;
83 SDRCacheMap sdrCacheMap __attribute__((init_priority(101)));
84
85 using SensorThresholdMap =
86 std::unordered_map<uint8_t, get_sdr::GetSensorThresholdsResponse>;
87 SensorThresholdMap sensorThresholdMap __attribute__((init_priority(101)));
88
89 #ifdef FEATURE_SENSORS_CACHE
90 std::map<uint8_t, std::unique_ptr<sdbusplus::bus::match_t>> sensorAddedMatches
91 __attribute__((init_priority(101)));
92 std::map<uint8_t, std::unique_ptr<sdbusplus::bus::match_t>> sensorUpdatedMatches
93 __attribute__((init_priority(101)));
94 std::map<uint8_t, std::unique_ptr<sdbusplus::bus::match_t>> sensorRemovedMatches
95 __attribute__((init_priority(101)));
96 std::unique_ptr<sdbusplus::bus::match_t> sensorsOwnerMatch
97 __attribute__((init_priority(101)));
98
99 ipmi::sensor::SensorCacheMap sensorCacheMap __attribute__((init_priority(101)));
100
101 // It is needed to know which objects belong to which service, so that when a
102 // service exits without interfacesRemoved signal, we could invaildate the cache
103 // that is related to the service. It uses below two variables:
104 // - idToServiceMap records which sensors are known to have a related service;
105 // - serviceToIdMap maps a service to the sensors.
106 using sensorIdToServiceMap = std::unordered_map<uint8_t, std::string>;
107 sensorIdToServiceMap idToServiceMap __attribute__((init_priority(101)));
108
109 using sensorServiceToIdMap = std::unordered_map<std::string, std::set<uint8_t>>;
110 sensorServiceToIdMap serviceToIdMap __attribute__((init_priority(101)));
111
fillSensorIdServiceMap(const std::string &,const std::string &,uint8_t id,const std::string & service)112 static void fillSensorIdServiceMap(const std::string&,
113 const std::string& /*intf*/, uint8_t id,
114 const std::string& service)
115 {
116 if (idToServiceMap.find(id) != idToServiceMap.end())
117 {
118 return;
119 }
120 idToServiceMap[id] = service;
121 serviceToIdMap[service].insert(id);
122 }
123
fillSensorIdServiceMap(const std::string & obj,const std::string & intf,uint8_t id)124 static void fillSensorIdServiceMap(const std::string& obj,
125 const std::string& intf, uint8_t id)
126 {
127 if (idToServiceMap.find(id) != idToServiceMap.end())
128 {
129 return;
130 }
131 try
132 {
133 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
134 auto service = ipmi::getService(bus, intf, obj);
135 idToServiceMap[id] = service;
136 serviceToIdMap[service].insert(id);
137 }
138 catch (...)
139 {
140 // Ignore
141 }
142 }
143
initSensorMatches()144 void initSensorMatches()
145 {
146 using namespace sdbusplus::bus::match::rules;
147 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
148 for (const auto& s : ipmi::sensor::sensors)
149 {
150 sensorAddedMatches.emplace(
151 s.first,
152 std::make_unique<sdbusplus::bus::match_t>(
153 bus, interfacesAdded() + argNpath(0, s.second.sensorPath),
154 [id = s.first, obj = s.second.sensorPath,
155 intf = s.second.propertyInterfaces.begin()->first](
156 auto& /*msg*/) { fillSensorIdServiceMap(obj, intf, id); }));
157 sensorRemovedMatches.emplace(
158 s.first,
159 std::make_unique<sdbusplus::bus::match_t>(
160 bus, interfacesRemoved() + argNpath(0, s.second.sensorPath),
161 [id = s.first](auto& /*msg*/) {
162 // Ideally this should work.
163 // But when a service is terminated or crashed, it does not
164 // emit interfacesRemoved signal. In that case it's handled
165 // by sensorsOwnerMatch
166 sensorCacheMap[id].reset();
167 }));
168 sensorUpdatedMatches.emplace(
169 s.first,
170 std::make_unique<sdbusplus::bus::match_t>(
171 bus,
172 type::signal() + path(s.second.sensorPath) +
173 member("PropertiesChanged"s) +
174 interface("org.freedesktop.DBus.Properties"s),
175 [&s](auto& msg) {
176 fillSensorIdServiceMap(
177 s.second.sensorPath,
178 s.second.propertyInterfaces.begin()->first, s.first);
179 try
180 {
181 // This is signal callback
182 std::string interfaceName;
183 msg.read(interfaceName);
184 ipmi::PropertyMap props;
185 msg.read(props);
186 s.second.getFunc(s.first, s.second, props);
187 }
188 catch (const std::exception& e)
189 {
190 sensorCacheMap[s.first].reset();
191 }
192 }));
193 }
194 sensorsOwnerMatch = std::make_unique<sdbusplus::bus::match_t>(
195 bus, nameOwnerChanged(), [](auto& msg) {
196 std::string name;
197 std::string oldOwner;
198 std::string newOwner;
199 msg.read(name, oldOwner, newOwner);
200
201 if (!name.empty() && newOwner.empty())
202 {
203 // The service exits
204 const auto it = serviceToIdMap.find(name);
205 if (it == serviceToIdMap.end())
206 {
207 return;
208 }
209 for (const auto& id : it->second)
210 {
211 // Invalidate cache
212 sensorCacheMap[id].reset();
213 }
214 }
215 });
216 }
217 #endif
218
219 // Use a lookup table to find the interface name of a specific sensor
220 // This will be used until an alternative is found. this is the first
221 // step for mapping IPMI
find_openbmc_path(uint8_t num,dbus_interface_t * interface)222 int find_openbmc_path(uint8_t num, dbus_interface_t* interface)
223 {
224 const auto& sensor_it = ipmi::sensor::sensors.find(num);
225 if (sensor_it == ipmi::sensor::sensors.end())
226 {
227 // The sensor map does not contain the sensor requested
228 return -EINVAL;
229 }
230
231 const auto& info = sensor_it->second;
232
233 std::string serviceName{};
234 try
235 {
236 sdbusplus::bus_t bus{ipmid_get_sd_bus_connection()};
237 serviceName =
238 ipmi::getService(bus, info.sensorInterface, info.sensorPath);
239 }
240 catch (const sdbusplus::exception_t&)
241 {
242 std::fprintf(stderr, "Failed to get %s busname: %s\n",
243 info.sensorPath.c_str(), serviceName.c_str());
244 return -EINVAL;
245 }
246
247 interface->sensortype = info.sensorType;
248 strcpy(interface->bus, serviceName.c_str());
249 strcpy(interface->path, info.sensorPath.c_str());
250 // Take the interface name from the beginning of the DbusInterfaceMap. This
251 // works for the Value interface but may not suffice for more complex
252 // sensors.
253 // tracked https://github.com/openbmc/phosphor-host-ipmid/issues/103
254 strcpy(interface->interface,
255 info.propertyInterfaces.begin()->first.c_str());
256 interface->sensornumber = num;
257
258 return 0;
259 }
260
261 /////////////////////////////////////////////////////////////////////
262 //
263 // Routines used by ipmi commands wanting to interact on the dbus
264 //
265 /////////////////////////////////////////////////////////////////////
set_sensor_dbus_state_s(uint8_t number,const char * method,const char * value)266 int set_sensor_dbus_state_s(uint8_t number, const char* method,
267 const char* value)
268 {
269 dbus_interface_t a;
270 int r;
271 sd_bus_error error = SD_BUS_ERROR_NULL;
272 sd_bus_message* m = NULL;
273
274 r = find_openbmc_path(number, &a);
275
276 if (r < 0)
277 {
278 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
279 return 0;
280 }
281
282 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
283 method);
284 if (r < 0)
285 {
286 std::fprintf(stderr, "Failed to create a method call: %s",
287 strerror(-r));
288 goto final;
289 }
290
291 r = sd_bus_message_append(m, "v", "s", value);
292 if (r < 0)
293 {
294 std::fprintf(stderr, "Failed to create a input parameter: %s",
295 strerror(-r));
296 goto final;
297 }
298
299 r = sd_bus_call(bus, m, 0, &error, NULL);
300 if (r < 0)
301 {
302 std::fprintf(stderr, "Failed to call the method: %s", strerror(-r));
303 }
304
305 final:
306 sd_bus_error_free(&error);
307 m = sd_bus_message_unref(m);
308
309 return 0;
310 }
set_sensor_dbus_state_y(uint8_t number,const char * method,const uint8_t value)311 int set_sensor_dbus_state_y(uint8_t number, const char* method,
312 const uint8_t value)
313 {
314 dbus_interface_t a;
315 int r;
316 sd_bus_error error = SD_BUS_ERROR_NULL;
317 sd_bus_message* m = NULL;
318
319 r = find_openbmc_path(number, &a);
320
321 if (r < 0)
322 {
323 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
324 return 0;
325 }
326
327 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
328 method);
329 if (r < 0)
330 {
331 std::fprintf(stderr, "Failed to create a method call: %s",
332 strerror(-r));
333 goto final;
334 }
335
336 r = sd_bus_message_append(m, "v", "i", value);
337 if (r < 0)
338 {
339 std::fprintf(stderr, "Failed to create a input parameter: %s",
340 strerror(-r));
341 goto final;
342 }
343
344 r = sd_bus_call(bus, m, 0, &error, NULL);
345 if (r < 0)
346 {
347 std::fprintf(stderr, "12 Failed to call the method: %s", strerror(-r));
348 }
349
350 final:
351 sd_bus_error_free(&error);
352 m = sd_bus_message_unref(m);
353
354 return 0;
355 }
356
dbus_to_sensor_type(char * p)357 uint8_t dbus_to_sensor_type(char* p)
358 {
359 sensorTypemap_t* s = g_SensorTypeMap;
360 char r = 0;
361 while (s->number != 0xFF)
362 {
363 if (!strcmp(s->dbusname, p))
364 {
365 r = s->typecode;
366 break;
367 }
368 s++;
369 }
370
371 if (s->number == 0xFF)
372 printf("Failed to find Sensor Type %s\n", p);
373
374 return r;
375 }
376
get_type_from_interface(dbus_interface_t dbus_if)377 uint8_t get_type_from_interface(dbus_interface_t dbus_if)
378 {
379 uint8_t type;
380
381 // This is where sensors that do not exist in dbus but do
382 // exist in the host code stop. This should indicate it
383 // is not a supported sensor
384 if (dbus_if.interface[0] == 0)
385 {
386 return 0;
387 }
388
389 // Fetch type from interface itself.
390 if (dbus_if.sensortype != 0)
391 {
392 type = dbus_if.sensortype;
393 }
394 else
395 {
396 // Non InventoryItems
397 char* p = strrchr(dbus_if.path, '/');
398 type = dbus_to_sensor_type(p + 1);
399 }
400
401 return type;
402 }
403
404 // Replaces find_sensor
find_type_for_sensor_number(uint8_t num)405 uint8_t find_type_for_sensor_number(uint8_t num)
406 {
407 int r;
408 dbus_interface_t dbus_if;
409 r = find_openbmc_path(num, &dbus_if);
410 if (r < 0)
411 {
412 std::fprintf(stderr, "Could not find sensor %d\n", num);
413 return 0;
414 }
415 return get_type_from_interface(dbus_if);
416 }
417
418 /**
419 * @brief implements the get sensor type command.
420 * @param - sensorNumber
421 *
422 * @return IPMI completion code plus response data on success.
423 * - sensorType
424 * - eventType
425 **/
426
427 ipmi::RspType<uint8_t, // sensorType
428 uint8_t // eventType
429 >
ipmiGetSensorType(uint8_t sensorNumber)430 ipmiGetSensorType(uint8_t sensorNumber)
431 {
432 const auto it = ipmi::sensor::sensors.find(sensorNumber);
433 if (it == ipmi::sensor::sensors.end())
434 {
435 // The sensor map does not contain the sensor requested
436 return ipmi::responseSensorInvalid();
437 }
438
439 const auto& info = it->second;
440 uint8_t sensorType = info.sensorType;
441 uint8_t eventType = info.sensorReadingType;
442
443 return ipmi::responseSuccess(sensorType, eventType);
444 }
445
446 const std::set<std::string> analogSensorInterfaces = {
447 "xyz.openbmc_project.Sensor.Value",
448 "xyz.openbmc_project.Control.FanPwm",
449 };
450
isAnalogSensor(const std::string & interface)451 bool isAnalogSensor(const std::string& interface)
452 {
453 return (analogSensorInterfaces.count(interface));
454 }
455
456 /**
457 @brief This command is used to set sensorReading.
458
459 @param
460 - sensorNumber
461 - operation
462 - reading
463 - assertOffset0_7
464 - assertOffset8_14
465 - deassertOffset0_7
466 - deassertOffset8_14
467 - eventData1
468 - eventData2
469 - eventData3
470
471 @return completion code on success.
472 **/
473
ipmiSetSensorReading(uint8_t sensorNumber,uint8_t operation,uint8_t reading,uint8_t assertOffset0_7,uint8_t assertOffset8_14,uint8_t deassertOffset0_7,uint8_t deassertOffset8_14,uint8_t eventData1,uint8_t eventData2,uint8_t eventData3)474 ipmi::RspType<> ipmiSetSensorReading(
475 uint8_t sensorNumber, uint8_t operation, uint8_t reading,
476 uint8_t assertOffset0_7, uint8_t assertOffset8_14,
477 uint8_t deassertOffset0_7, uint8_t deassertOffset8_14, uint8_t eventData1,
478 uint8_t eventData2, uint8_t eventData3)
479 {
480 lg2::debug("IPMI SET_SENSOR, sensorNumber: {SENSOR_NUM}", "SENSOR_NUM",
481 lg2::hex, sensorNumber);
482
483 if (sensorNumber == 0xFF)
484 {
485 return ipmi::responseInvalidFieldRequest();
486 }
487 ipmi::sensor::SetSensorReadingReq cmdData;
488
489 cmdData.number = sensorNumber;
490 cmdData.operation = operation;
491 cmdData.reading = reading;
492 cmdData.assertOffset0_7 = assertOffset0_7;
493 cmdData.assertOffset8_14 = assertOffset8_14;
494 cmdData.deassertOffset0_7 = deassertOffset0_7;
495 cmdData.deassertOffset8_14 = deassertOffset8_14;
496 cmdData.eventData1 = eventData1;
497 cmdData.eventData2 = eventData2;
498 cmdData.eventData3 = eventData3;
499
500 // Check if the Sensor Number is present
501 const auto iter = ipmi::sensor::sensors.find(sensorNumber);
502 if (iter == ipmi::sensor::sensors.end())
503 {
504 updateSensorRecordFromSSRAESC(&sensorNumber);
505 return ipmi::responseSuccess();
506 }
507
508 try
509 {
510 if (ipmi::sensor::Mutability::Write !=
511 (iter->second.mutability & ipmi::sensor::Mutability::Write))
512 {
513 lg2::error("Sensor Set operation is not allowed, "
514 "sensorNumber: {SENSOR_NUM}",
515 "SENSOR_NUM", lg2::hex, sensorNumber);
516 return ipmi::responseIllegalCommand();
517 }
518 auto ipmiRC = iter->second.updateFunc(cmdData, iter->second);
519 return ipmi::response(ipmiRC);
520 }
521 catch (const InternalFailure& e)
522 {
523 lg2::error("Set sensor failed, sensorNumber: {SENSOR_NUM}",
524 "SENSOR_NUM", lg2::hex, sensorNumber);
525 commit<InternalFailure>();
526 return ipmi::responseUnspecifiedError();
527 }
528 catch (const std::runtime_error& e)
529 {
530 lg2::error("runtime error: {ERROR}", "ERROR", e);
531 return ipmi::responseUnspecifiedError();
532 }
533 }
534
535 /** @brief implements the get sensor reading command
536 * @param sensorNum - sensor number
537 *
538 * @returns IPMI completion code plus response data
539 * - senReading - sensor reading
540 * - reserved
541 * - readState - sensor reading state enabled
542 * - senScanState - sensor scan state disabled
543 * - allEventMessageState - all Event message state disabled
544 * - assertionStatesLsb - threshold levels states
545 * - assertionStatesMsb - discrete reading sensor states
546 */
547 ipmi::RspType<uint8_t, // sensor reading
548
549 uint5_t, // reserved
550 bool, // reading state
551 bool, // 0 = sensor scanning state disabled
552 bool, // 0 = all event messages disabled
553
554 uint8_t, // threshold levels states
555 uint8_t // discrete reading sensor states
556 >
ipmiSensorGetSensorReading(ipmi::Context::ptr & ctx,uint8_t sensorNum)557 ipmiSensorGetSensorReading([[maybe_unused]] ipmi::Context::ptr& ctx,
558 uint8_t sensorNum)
559 {
560 if (sensorNum == 0xFF)
561 {
562 return ipmi::responseInvalidFieldRequest();
563 }
564
565 const auto iter = ipmi::sensor::sensors.find(sensorNum);
566 if (iter == ipmi::sensor::sensors.end())
567 {
568 return ipmi::responseSensorInvalid();
569 }
570 if (ipmi::sensor::Mutability::Read !=
571 (iter->second.mutability & ipmi::sensor::Mutability::Read))
572 {
573 return ipmi::responseIllegalCommand();
574 }
575
576 try
577 {
578 #ifdef FEATURE_SENSORS_CACHE
579 auto& sensorData = sensorCacheMap[sensorNum];
580 if (!sensorData.has_value())
581 {
582 // No cached value, try read it
583 std::string service;
584 boost::system::error_code ec;
585 const auto& sensorInfo = iter->second;
586 ec = ipmi::getService(ctx, sensorInfo.sensorInterface,
587 sensorInfo.sensorPath, service);
588 if (ec)
589 {
590 return ipmi::responseUnspecifiedError();
591 }
592 fillSensorIdServiceMap(sensorInfo.sensorPath,
593 sensorInfo.propertyInterfaces.begin()->first,
594 iter->first, service);
595
596 ipmi::PropertyMap props;
597 ec = ipmi::getAllDbusProperties(
598 ctx, service, sensorInfo.sensorPath,
599 sensorInfo.propertyInterfaces.begin()->first, props);
600 if (ec)
601 {
602 fprintf(stderr, "Failed to get sensor %s, %d: %s\n",
603 sensorInfo.sensorPath.c_str(), ec.value(),
604 ec.message().c_str());
605 // Intitilizing with default values
606 constexpr uint8_t senReading = 0;
607 constexpr uint5_t reserved{0};
608 constexpr bool readState = true;
609 constexpr bool senScanState = false;
610 constexpr bool allEventMessageState = false;
611 constexpr uint8_t assertionStatesLsb = 0;
612 constexpr uint8_t assertionStatesMsb = 0;
613
614 return ipmi::responseSuccess(
615 senReading, reserved, readState, senScanState,
616 allEventMessageState, assertionStatesLsb,
617 assertionStatesMsb);
618 }
619 sensorInfo.getFunc(sensorNum, sensorInfo, props);
620 }
621 return ipmi::responseSuccess(
622 sensorData->response.reading, uint5_t(0),
623 sensorData->response.readingOrStateUnavailable,
624 sensorData->response.scanningEnabled,
625 sensorData->response.allEventMessagesEnabled,
626 sensorData->response.thresholdLevelsStates,
627 sensorData->response.discreteReadingSensorStates);
628
629 #else
630 ipmi::sensor::GetSensorResponse getResponse =
631 iter->second.getFunc(iter->second);
632
633 return ipmi::responseSuccess(
634 getResponse.reading, uint5_t(0),
635 getResponse.readingOrStateUnavailable, getResponse.scanningEnabled,
636 getResponse.allEventMessagesEnabled,
637 getResponse.thresholdLevelsStates,
638 getResponse.discreteReadingSensorStates);
639 #endif
640 }
641 #ifdef UPDATE_FUNCTIONAL_ON_FAIL
642 catch (const SensorFunctionalError& e)
643 {
644 return ipmi::responseResponseError();
645 }
646 #endif
647 catch (const std::exception& e)
648 {
649 // Intitilizing with default values
650 constexpr uint8_t senReading = 0;
651 constexpr uint5_t reserved{0};
652 constexpr bool readState = true;
653 constexpr bool senScanState = false;
654 constexpr bool allEventMessageState = false;
655 constexpr uint8_t assertionStatesLsb = 0;
656 constexpr uint8_t assertionStatesMsb = 0;
657
658 return ipmi::responseSuccess(senReading, reserved, readState,
659 senScanState, allEventMessageState,
660 assertionStatesLsb, assertionStatesMsb);
661 }
662 }
663
664 get_sdr::GetSensorThresholdsResponse
getSensorThresholds(ipmi::Context::ptr & ctx,uint8_t sensorNum)665 getSensorThresholds(ipmi::Context::ptr& ctx, uint8_t sensorNum)
666 {
667 get_sdr::GetSensorThresholdsResponse resp{};
668 constexpr auto warningThreshIntf =
669 "xyz.openbmc_project.Sensor.Threshold.Warning";
670 constexpr auto criticalThreshIntf =
671 "xyz.openbmc_project.Sensor.Threshold.Critical";
672
673 const auto iter = ipmi::sensor::sensors.find(sensorNum);
674 const auto info = iter->second;
675
676 std::string service;
677 boost::system::error_code ec;
678 ec = ipmi::getService(ctx, info.sensorInterface, info.sensorPath, service);
679 if (ec)
680 {
681 return resp;
682 }
683
684 ipmi::PropertyMap warnThresholds;
685 ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
686 warningThreshIntf, warnThresholds);
687 int32_t minClamp;
688 int32_t maxClamp;
689 int32_t rawData;
690 constexpr uint8_t sensorUnitsSignedBits = 2 << 6;
691 constexpr uint8_t signedDataFormat = 0x80;
692 if ((info.sensorUnits1 & sensorUnitsSignedBits) == signedDataFormat)
693 {
694 minClamp = std::numeric_limits<int8_t>::lowest();
695 maxClamp = std::numeric_limits<int8_t>::max();
696 }
697 else
698 {
699 minClamp = std::numeric_limits<uint8_t>::lowest();
700 maxClamp = std::numeric_limits<uint8_t>::max();
701 }
702 if (!ec)
703 {
704 double warnLow = ipmi::mappedVariant<double>(
705 warnThresholds, "WarningLow",
706 std::numeric_limits<double>::quiet_NaN());
707 double warnHigh = ipmi::mappedVariant<double>(
708 warnThresholds, "WarningHigh",
709 std::numeric_limits<double>::quiet_NaN());
710
711 if (std::isfinite(warnLow))
712 {
713 warnLow *= std::pow(10, info.scale - info.exponentR);
714 rawData = round((warnLow - info.scaledOffset) / info.coefficientM);
715 resp.lowerNonCritical =
716 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
717 resp.validMask |= static_cast<uint8_t>(
718 ipmi::sensor::ThresholdMask::NON_CRITICAL_LOW_MASK);
719 }
720
721 if (std::isfinite(warnHigh))
722 {
723 warnHigh *= std::pow(10, info.scale - info.exponentR);
724 rawData = round((warnHigh - info.scaledOffset) / info.coefficientM);
725 resp.upperNonCritical =
726 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
727 resp.validMask |= static_cast<uint8_t>(
728 ipmi::sensor::ThresholdMask::NON_CRITICAL_HIGH_MASK);
729 }
730 }
731
732 ipmi::PropertyMap critThresholds;
733 ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
734 criticalThreshIntf, critThresholds);
735 if (!ec)
736 {
737 double critLow = ipmi::mappedVariant<double>(
738 critThresholds, "CriticalLow",
739 std::numeric_limits<double>::quiet_NaN());
740 double critHigh = ipmi::mappedVariant<double>(
741 critThresholds, "CriticalHigh",
742 std::numeric_limits<double>::quiet_NaN());
743
744 if (std::isfinite(critLow))
745 {
746 critLow *= std::pow(10, info.scale - info.exponentR);
747 rawData = round((critLow - info.scaledOffset) / info.coefficientM);
748 resp.lowerCritical =
749 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
750 resp.validMask |= static_cast<uint8_t>(
751 ipmi::sensor::ThresholdMask::CRITICAL_LOW_MASK);
752 }
753
754 if (std::isfinite(critHigh))
755 {
756 critHigh *= std::pow(10, info.scale - info.exponentR);
757 rawData = round((critHigh - info.scaledOffset) / info.coefficientM);
758 resp.upperCritical =
759 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
760 resp.validMask |= static_cast<uint8_t>(
761 ipmi::sensor::ThresholdMask::CRITICAL_HIGH_MASK);
762 }
763 }
764
765 return resp;
766 }
767
768 /** @brief implements the get sensor thresholds command
769 * @param ctx - IPMI context pointer
770 * @param sensorNum - sensor number
771 *
772 * @returns IPMI completion code plus response data
773 * - validMask - threshold mask
774 * - lower non-critical threshold - IPMI messaging state
775 * - lower critical threshold - link authentication state
776 * - lower non-recoverable threshold - callback state
777 * - upper non-critical threshold
778 * - upper critical
779 * - upper non-recoverable
780 */
781 ipmi::RspType<uint8_t, // validMask
782 uint8_t, // lowerNonCritical
783 uint8_t, // lowerCritical
784 uint8_t, // lowerNonRecoverable
785 uint8_t, // upperNonCritical
786 uint8_t, // upperCritical
787 uint8_t // upperNonRecoverable
788 >
ipmiSensorGetSensorThresholds(ipmi::Context::ptr & ctx,uint8_t sensorNum)789 ipmiSensorGetSensorThresholds(ipmi::Context::ptr& ctx, uint8_t sensorNum)
790 {
791 constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
792
793 const auto iter = ipmi::sensor::sensors.find(sensorNum);
794 if (iter == ipmi::sensor::sensors.end())
795 {
796 return ipmi::responseSensorInvalid();
797 }
798
799 const auto info = iter->second;
800
801 // Proceed only if the sensor value interface is implemented.
802 if (info.propertyInterfaces.find(valueInterface) ==
803 info.propertyInterfaces.end())
804 {
805 // return with valid mask as 0
806 return ipmi::responseSuccess();
807 }
808
809 auto it = sensorThresholdMap.find(sensorNum);
810 if (it == sensorThresholdMap.end())
811 {
812 sensorThresholdMap[sensorNum] = getSensorThresholds(ctx, sensorNum);
813 }
814
815 const auto& resp = sensorThresholdMap[sensorNum];
816
817 return ipmi::responseSuccess(
818 resp.validMask, resp.lowerNonCritical, resp.lowerCritical,
819 resp.lowerNonRecoverable, resp.upperNonCritical, resp.upperCritical,
820 resp.upperNonRecoverable);
821 }
822
823 /** @brief implements the Set Sensor threshold command
824 * @param sensorNumber - sensor number
825 * @param lowerNonCriticalThreshMask
826 * @param lowerCriticalThreshMask
827 * @param lowerNonRecovThreshMask
828 * @param upperNonCriticalThreshMask
829 * @param upperCriticalThreshMask
830 * @param upperNonRecovThreshMask
831 * @param reserved
832 * @param lowerNonCritical - lower non-critical threshold
833 * @param lowerCritical - Lower critical threshold
834 * @param lowerNonRecoverable - Lower non recovarable threshold
835 * @param upperNonCritical - Upper non-critical threshold
836 * @param upperCritical - Upper critical
837 * @param upperNonRecoverable - Upper Non-recoverable
838 *
839 * @returns IPMI completion code
840 */
ipmiSenSetSensorThresholds(ipmi::Context::ptr & ctx,uint8_t sensorNum,bool lowerNonCriticalThreshMask,bool lowerCriticalThreshMask,bool lowerNonRecovThreshMask,bool upperNonCriticalThreshMask,bool upperCriticalThreshMask,bool upperNonRecovThreshMask,uint2_t reserved,uint8_t lowerNonCritical,uint8_t lowerCritical,uint8_t,uint8_t upperNonCritical,uint8_t upperCritical,uint8_t)841 ipmi::RspType<> ipmiSenSetSensorThresholds(
842 ipmi::Context::ptr& ctx, uint8_t sensorNum, bool lowerNonCriticalThreshMask,
843 bool lowerCriticalThreshMask, bool lowerNonRecovThreshMask,
844 bool upperNonCriticalThreshMask, bool upperCriticalThreshMask,
845 bool upperNonRecovThreshMask, uint2_t reserved, uint8_t lowerNonCritical,
846 uint8_t lowerCritical, uint8_t, uint8_t upperNonCritical,
847 uint8_t upperCritical, uint8_t)
848 {
849 if (reserved)
850 {
851 return ipmi::responseInvalidFieldRequest();
852 }
853
854 // lower nc and upper nc not suppported on any sensor
855 if (lowerNonRecovThreshMask || upperNonRecovThreshMask)
856 {
857 return ipmi::responseInvalidFieldRequest();
858 }
859
860 // if none of the threshold mask are set, nothing to do
861 if (!(lowerNonCriticalThreshMask | lowerCriticalThreshMask |
862 lowerNonRecovThreshMask | upperNonCriticalThreshMask |
863 upperCriticalThreshMask | upperNonRecovThreshMask))
864 {
865 return ipmi::responseSuccess();
866 }
867
868 constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
869
870 const auto iter = ipmi::sensor::sensors.find(sensorNum);
871 if (iter == ipmi::sensor::sensors.end())
872 {
873 return ipmi::responseSensorInvalid();
874 }
875
876 const auto& info = iter->second;
877
878 // Proceed only if the sensor value interface is implemented.
879 if (info.propertyInterfaces.find(valueInterface) ==
880 info.propertyInterfaces.end())
881 {
882 // return with valid mask as 0
883 return ipmi::responseSuccess();
884 }
885
886 constexpr auto warningThreshIntf =
887 "xyz.openbmc_project.Sensor.Threshold.Warning";
888 constexpr auto criticalThreshIntf =
889 "xyz.openbmc_project.Sensor.Threshold.Critical";
890
891 std::string service;
892 boost::system::error_code ec;
893 ec = ipmi::getService(ctx, info.sensorInterface, info.sensorPath, service);
894 if (ec)
895 {
896 return ipmi::responseResponseError();
897 }
898 // store a vector of property name, value to set, and interface
899 std::vector<std::tuple<std::string, uint8_t, std::string>> thresholdsToSet;
900
901 // define the indexes of the tuple
902 constexpr uint8_t propertyName = 0;
903 constexpr uint8_t thresholdValue = 1;
904 constexpr uint8_t interface = 2;
905 // verifiy all needed fields are present
906 if (lowerCriticalThreshMask || upperCriticalThreshMask)
907 {
908 ipmi::PropertyMap findThreshold;
909 ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
910 criticalThreshIntf, findThreshold);
911
912 if (!ec)
913 {
914 if (lowerCriticalThreshMask)
915 {
916 auto findLower = findThreshold.find("CriticalLow");
917 if (findLower == findThreshold.end())
918 {
919 return ipmi::responseInvalidFieldRequest();
920 }
921 thresholdsToSet.emplace_back("CriticalLow", lowerCritical,
922 criticalThreshIntf);
923 }
924 if (upperCriticalThreshMask)
925 {
926 auto findUpper = findThreshold.find("CriticalHigh");
927 if (findUpper == findThreshold.end())
928 {
929 return ipmi::responseInvalidFieldRequest();
930 }
931 thresholdsToSet.emplace_back("CriticalHigh", upperCritical,
932 criticalThreshIntf);
933 }
934 }
935 }
936 if (lowerNonCriticalThreshMask || upperNonCriticalThreshMask)
937 {
938 ipmi::PropertyMap findThreshold;
939 ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
940 warningThreshIntf, findThreshold);
941
942 if (!ec)
943 {
944 if (lowerNonCriticalThreshMask)
945 {
946 auto findLower = findThreshold.find("WarningLow");
947 if (findLower == findThreshold.end())
948 {
949 return ipmi::responseInvalidFieldRequest();
950 }
951 thresholdsToSet.emplace_back("WarningLow", lowerNonCritical,
952 warningThreshIntf);
953 }
954 if (upperNonCriticalThreshMask)
955 {
956 auto findUpper = findThreshold.find("WarningHigh");
957 if (findUpper == findThreshold.end())
958 {
959 return ipmi::responseInvalidFieldRequest();
960 }
961 thresholdsToSet.emplace_back("WarningHigh", upperNonCritical,
962 warningThreshIntf);
963 }
964 }
965 }
966 for (const auto& property : thresholdsToSet)
967 {
968 // from section 36.3 in the IPMI Spec, assume all linear
969 double valueToSet =
970 ((info.coefficientM * std::get<thresholdValue>(property)) +
971 (info.scaledOffset * std::pow(10.0, info.scale))) *
972 std::pow(10.0, info.exponentR);
973 ipmi::setDbusProperty(
974 ctx, service, info.sensorPath, std::get<interface>(property),
975 std::get<propertyName>(property), ipmi::Value(valueToSet));
976 }
977
978 // Invalidate the cache
979 sensorThresholdMap.erase(sensorNum);
980 return ipmi::responseSuccess();
981 }
982
983 /** @brief implements the get SDR Info command
984 * @param count - Operation
985 *
986 * @returns IPMI completion code plus response data
987 * - sdrCount - sensor/SDR count
988 * - lunsAndDynamicPopulation - static/Dynamic sensor population flag
989 */
990 ipmi::RspType<uint8_t, // respcount
991 uint8_t // dynamic population flags
992 >
ipmiSensorGetDeviceSdrInfo(std::optional<uint8_t> count)993 ipmiSensorGetDeviceSdrInfo(std::optional<uint8_t> count)
994 {
995 uint8_t sdrCount;
996 // multiple LUNs not supported.
997 constexpr uint8_t lunsAndDynamicPopulation = 1;
998 constexpr uint8_t getSdrCount = 0x01;
999 constexpr uint8_t getSensorCount = 0x00;
1000
1001 if (count.value_or(0) == getSdrCount)
1002 {
1003 // Get SDR count. This returns the total number of SDRs in the device.
1004 const auto& entityRecords =
1005 ipmi::sensor::EntityInfoMapContainer::getContainer()
1006 ->getIpmiEntityRecords();
1007 sdrCount = ipmi::sensor::sensors.size() + frus.size() +
1008 entityRecords.size();
1009 }
1010 else if (count.value_or(0) == getSensorCount)
1011 {
1012 // Get Sensor count. This returns the number of sensors
1013 sdrCount = ipmi::sensor::sensors.size();
1014 }
1015 else
1016 {
1017 return ipmi::responseInvalidCommandOnLun();
1018 }
1019
1020 return ipmi::responseSuccess(sdrCount, lunsAndDynamicPopulation);
1021 }
1022
1023 /** @brief implements the reserve SDR command
1024 * @returns IPMI completion code plus response data
1025 * - reservationID - reservation ID
1026 */
ipmiSensorReserveSdr()1027 ipmi::RspType<uint16_t> ipmiSensorReserveSdr()
1028 {
1029 // A constant reservation ID is okay until we implement add/remove SDR.
1030 constexpr uint16_t reservationID = 1;
1031
1032 return ipmi::responseSuccess(reservationID);
1033 }
1034
setUnitFieldsForObject(const ipmi::sensor::Info * info,get_sdr::SensorDataFullRecordBody * body)1035 void setUnitFieldsForObject(const ipmi::sensor::Info* info,
1036 get_sdr::SensorDataFullRecordBody* body)
1037 {
1038 namespace server = sdbusplus::server::xyz::openbmc_project::sensor;
1039 try
1040 {
1041 auto unit = server::Value::convertUnitFromString(info->unit);
1042 // Unit strings defined in
1043 // phosphor-dbus-interfaces/xyz/openbmc_project/Sensor/Value.interface.yaml
1044 switch (unit)
1045 {
1046 case server::Value::Unit::DegreesC:
1047 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_DEGREES_C;
1048 break;
1049 case server::Value::Unit::RPMS:
1050 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_RPM;
1051 break;
1052 case server::Value::Unit::Volts:
1053 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_VOLTS;
1054 break;
1055 case server::Value::Unit::Meters:
1056 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_METERS;
1057 break;
1058 case server::Value::Unit::Amperes:
1059 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_AMPERES;
1060 break;
1061 case server::Value::Unit::Joules:
1062 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_JOULES;
1063 break;
1064 case server::Value::Unit::Watts:
1065 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_WATTS;
1066 break;
1067 default:
1068 // Cannot be hit.
1069 std::fprintf(stderr, "Unknown value unit type: = %s\n",
1070 info->unit.c_str());
1071 }
1072 }
1073 catch (const sdbusplus::exception::InvalidEnumString& e)
1074 {
1075 lg2::warning("Warning: no unit provided for sensor!");
1076 }
1077 }
1078
populate_record_from_dbus(get_sdr::SensorDataFullRecordBody * body,const ipmi::sensor::Info * info,ipmi_data_len_t)1079 ipmi_ret_t populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
1080 const ipmi::sensor::Info* info,
1081 ipmi_data_len_t)
1082 {
1083 /* Functional sensor case */
1084 if (isAnalogSensor(info->propertyInterfaces.begin()->first))
1085 {
1086 body->sensor_units_1 = info->sensorUnits1; // default is 0. unsigned, no
1087 // rate, no modifier, not a %
1088 /* Unit info */
1089 setUnitFieldsForObject(info, body);
1090
1091 get_sdr::body::set_b(info->coefficientB, body);
1092 get_sdr::body::set_m(info->coefficientM, body);
1093 get_sdr::body::set_b_exp(info->exponentB, body);
1094 get_sdr::body::set_r_exp(info->exponentR, body);
1095 }
1096
1097 /* ID string */
1098 auto id_string = info->sensorName;
1099
1100 if (id_string.empty())
1101 {
1102 id_string = info->sensorNameFunc(*info);
1103 }
1104
1105 if (id_string.length() > FULL_RECORD_ID_STR_MAX_LENGTH)
1106 {
1107 get_sdr::body::set_id_strlen(FULL_RECORD_ID_STR_MAX_LENGTH, body);
1108 }
1109 else
1110 {
1111 get_sdr::body::set_id_strlen(id_string.length(), body);
1112 }
1113 get_sdr::body::set_id_type(3, body); // "8-bit ASCII + Latin 1"
1114 strncpy(body->id_string, id_string.c_str(),
1115 get_sdr::body::get_id_strlen(body));
1116
1117 return IPMI_CC_OK;
1118 };
1119
ipmi_fru_get_sdr(ipmi_request_t request,ipmi_response_t response,ipmi_data_len_t data_len)1120 ipmi_ret_t ipmi_fru_get_sdr(ipmi_request_t request, ipmi_response_t response,
1121 ipmi_data_len_t data_len)
1122 {
1123 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
1124 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
1125 get_sdr::SensorDataFruRecord record{};
1126 auto dataLength = 0;
1127
1128 auto fru = frus.begin();
1129 uint8_t fruID{};
1130 auto recordID = get_sdr::request::get_record_id(req);
1131
1132 fruID = recordID - FRU_RECORD_ID_START;
1133 fru = frus.find(fruID);
1134 if (fru == frus.end())
1135 {
1136 return IPMI_CC_SENSOR_INVALID;
1137 }
1138
1139 /* Header */
1140 get_sdr::header::set_record_id(recordID, &(record.header));
1141 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
1142 record.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
1143 record.header.record_length = sizeof(record.key) + sizeof(record.body);
1144
1145 /* Key */
1146 record.key.fruID = fruID;
1147 record.key.accessLun |= IPMI_LOGICAL_FRU;
1148 record.key.deviceAddress = BMCTargetAddress;
1149
1150 /* Body */
1151 record.body.entityID = fru->second[0].entityID;
1152 record.body.entityInstance = fru->second[0].entityInstance;
1153 record.body.deviceType = fruInventoryDevice;
1154 record.body.deviceTypeModifier = IPMIFruInventory;
1155
1156 /* Device ID string */
1157 auto deviceID =
1158 fru->second[0].path.substr(fru->second[0].path.find_last_of('/') + 1,
1159 fru->second[0].path.length());
1160
1161 if (deviceID.length() > get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH)
1162 {
1163 get_sdr::body::set_device_id_strlen(
1164 get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH, &(record.body));
1165 }
1166 else
1167 {
1168 get_sdr::body::set_device_id_strlen(deviceID.length(), &(record.body));
1169 }
1170
1171 strncpy(record.body.deviceID, deviceID.c_str(),
1172 get_sdr::body::get_device_id_strlen(&(record.body)));
1173
1174 if (++fru == frus.end())
1175 {
1176 // we have reached till end of fru, so assign the next record id to
1177 // 512(Max fru ID = 511) + Entity Record ID(may start with 0).
1178 const auto& entityRecords =
1179 ipmi::sensor::EntityInfoMapContainer::getContainer()
1180 ->getIpmiEntityRecords();
1181 auto next_record_id =
1182 (entityRecords.size())
1183 ? entityRecords.begin()->first + ENTITY_RECORD_ID_START
1184 : END_OF_RECORD;
1185 get_sdr::response::set_next_record_id(next_record_id, resp);
1186 }
1187 else
1188 {
1189 get_sdr::response::set_next_record_id(
1190 (FRU_RECORD_ID_START + fru->first), resp);
1191 }
1192
1193 // Check for invalid offset size
1194 if (req->offset > sizeof(record))
1195 {
1196 return IPMI_CC_PARM_OUT_OF_RANGE;
1197 }
1198
1199 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
1200 sizeof(record) - req->offset);
1201
1202 std::memcpy(resp->record_data,
1203 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
1204
1205 *data_len = dataLength;
1206 *data_len += 2; // additional 2 bytes for next record ID
1207
1208 return IPMI_CC_OK;
1209 }
1210
ipmi_entity_get_sdr(ipmi_request_t request,ipmi_response_t response,ipmi_data_len_t data_len)1211 ipmi_ret_t ipmi_entity_get_sdr(ipmi_request_t request, ipmi_response_t response,
1212 ipmi_data_len_t data_len)
1213 {
1214 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
1215 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
1216 get_sdr::SensorDataEntityRecord record{};
1217 auto dataLength = 0;
1218
1219 const auto& entityRecords =
1220 ipmi::sensor::EntityInfoMapContainer::getContainer()
1221 ->getIpmiEntityRecords();
1222 auto entity = entityRecords.begin();
1223 uint8_t entityRecordID;
1224 auto recordID = get_sdr::request::get_record_id(req);
1225
1226 entityRecordID = recordID - ENTITY_RECORD_ID_START;
1227 entity = entityRecords.find(entityRecordID);
1228 if (entity == entityRecords.end())
1229 {
1230 return IPMI_CC_SENSOR_INVALID;
1231 }
1232
1233 /* Header */
1234 get_sdr::header::set_record_id(recordID, &(record.header));
1235 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
1236 record.header.record_type = get_sdr::SENSOR_DATA_ENTITY_RECORD;
1237 record.header.record_length = sizeof(record.key) + sizeof(record.body);
1238
1239 /* Key */
1240 record.key.containerEntityId = entity->second.containerEntityId;
1241 record.key.containerEntityInstance = entity->second.containerEntityInstance;
1242 get_sdr::key::set_flags(entity->second.isList, entity->second.isLinked,
1243 &(record.key));
1244 record.key.entityId1 = entity->second.containedEntities[0].first;
1245 record.key.entityInstance1 = entity->second.containedEntities[0].second;
1246
1247 /* Body */
1248 record.body.entityId2 = entity->second.containedEntities[1].first;
1249 record.body.entityInstance2 = entity->second.containedEntities[1].second;
1250 record.body.entityId3 = entity->second.containedEntities[2].first;
1251 record.body.entityInstance3 = entity->second.containedEntities[2].second;
1252 record.body.entityId4 = entity->second.containedEntities[3].first;
1253 record.body.entityInstance4 = entity->second.containedEntities[3].second;
1254
1255 if (++entity == entityRecords.end())
1256 {
1257 get_sdr::response::set_next_record_id(END_OF_RECORD,
1258 resp); // last record
1259 }
1260 else
1261 {
1262 get_sdr::response::set_next_record_id(
1263 (ENTITY_RECORD_ID_START + entity->first), resp);
1264 }
1265
1266 // Check for invalid offset size
1267 if (req->offset > sizeof(record))
1268 {
1269 return IPMI_CC_PARM_OUT_OF_RANGE;
1270 }
1271
1272 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
1273 sizeof(record) - req->offset);
1274
1275 std::memcpy(resp->record_data,
1276 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
1277
1278 *data_len = dataLength;
1279 *data_len += 2; // additional 2 bytes for next record ID
1280
1281 return IPMI_CC_OK;
1282 }
1283
ipmi_sen_get_sdr(ipmi_netfn_t,ipmi_cmd_t,ipmi_request_t request,ipmi_response_t response,ipmi_data_len_t data_len,ipmi_context_t)1284 ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
1285 ipmi_response_t response, ipmi_data_len_t data_len,
1286 ipmi_context_t)
1287 {
1288 ipmi_ret_t ret = IPMI_CC_OK;
1289 get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
1290 get_sdr::GetSdrResp* resp = (get_sdr::GetSdrResp*)response;
1291
1292 // Note: we use an iterator so we can provide the next ID at the end of
1293 // the call.
1294 auto sensor = ipmi::sensor::sensors.begin();
1295 auto recordID = get_sdr::request::get_record_id(req);
1296
1297 // At the beginning of a scan, the host side will send us id=0.
1298 if (recordID != 0)
1299 {
1300 // recordID 0 to 255 means it is a FULL record.
1301 // recordID 256 to 511 means it is a FRU record.
1302 // recordID greater then 511 means it is a Entity Association
1303 // record. Currently we are supporting three record types: FULL
1304 // record, FRU record and Enttiy Association record.
1305 if (recordID >= ENTITY_RECORD_ID_START)
1306 {
1307 return ipmi_entity_get_sdr(request, response, data_len);
1308 }
1309 else if (recordID >= FRU_RECORD_ID_START &&
1310 recordID < ENTITY_RECORD_ID_START)
1311 {
1312 return ipmi_fru_get_sdr(request, response, data_len);
1313 }
1314 else
1315 {
1316 sensor = ipmi::sensor::sensors.find(recordID);
1317 if (sensor == ipmi::sensor::sensors.end())
1318 {
1319 return IPMI_CC_SENSOR_INVALID;
1320 }
1321 }
1322 }
1323
1324 uint8_t sensor_id = sensor->first;
1325
1326 auto it = sdrCacheMap.find(sensor_id);
1327 if (it == sdrCacheMap.end())
1328 {
1329 /* Header */
1330 get_sdr::SensorDataFullRecord record = {};
1331 get_sdr::header::set_record_id(sensor_id, &(record.header));
1332 record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
1333 record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
1334 record.header.record_length = sizeof(record.key) + sizeof(record.body);
1335
1336 /* Key */
1337 get_sdr::key::set_owner_id_bmc(&(record.key));
1338 record.key.sensor_number = sensor_id;
1339
1340 /* Body */
1341 record.body.entity_id = sensor->second.entityType;
1342 record.body.sensor_type = sensor->second.sensorType;
1343 record.body.event_reading_type = sensor->second.sensorReadingType;
1344 record.body.entity_instance = sensor->second.instance;
1345 if (ipmi::sensor::Mutability::Write ==
1346 (sensor->second.mutability & ipmi::sensor::Mutability::Write))
1347 {
1348 get_sdr::body::init_settable_state(true, &(record.body));
1349 }
1350
1351 // Set the type-specific details given the DBus interface
1352 populate_record_from_dbus(&(record.body), &(sensor->second), data_len);
1353 sdrCacheMap[sensor_id] = std::move(record);
1354 }
1355
1356 const auto& record = sdrCacheMap[sensor_id];
1357
1358 if (++sensor == ipmi::sensor::sensors.end())
1359 {
1360 // we have reached till end of sensor, so assign the next record id
1361 // to 256(Max Sensor ID = 255) + FRU ID(may start with 0).
1362 auto next_record_id = (frus.size())
1363 ? frus.begin()->first + FRU_RECORD_ID_START
1364 : END_OF_RECORD;
1365
1366 get_sdr::response::set_next_record_id(next_record_id, resp);
1367 }
1368 else
1369 {
1370 get_sdr::response::set_next_record_id(sensor->first, resp);
1371 }
1372
1373 if (req->offset > sizeof(record))
1374 {
1375 return IPMI_CC_PARM_OUT_OF_RANGE;
1376 }
1377
1378 // data_len will ultimately be the size of the record, plus
1379 // the size of the next record ID:
1380 *data_len = std::min(static_cast<size_t>(req->bytes_to_read),
1381 sizeof(record) - req->offset);
1382
1383 std::memcpy(resp->record_data,
1384 reinterpret_cast<const uint8_t*>(&record) + req->offset,
1385 *data_len);
1386
1387 // data_len should include the LSB and MSB:
1388 *data_len += sizeof(resp->next_record_id_lsb) +
1389 sizeof(resp->next_record_id_msb);
1390
1391 return ret;
1392 }
1393
isFromSystemChannel()1394 static bool isFromSystemChannel()
1395 {
1396 // TODO we could not figure out where the request is from based on IPMI
1397 // command handler parameters. because of it, we can not differentiate
1398 // request from SMS/SMM or IPMB channel
1399 return true;
1400 }
1401
ipmicmdPlatformEvent(ipmi_netfn_t,ipmi_cmd_t,ipmi_request_t request,ipmi_response_t,ipmi_data_len_t dataLen,ipmi_context_t)1402 ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t, ipmi_cmd_t,
1403 ipmi_request_t request, ipmi_response_t,
1404 ipmi_data_len_t dataLen, ipmi_context_t)
1405 {
1406 uint16_t generatorID;
1407 size_t count;
1408 bool assert = true;
1409 std::string sensorPath;
1410 size_t paraLen = *dataLen;
1411 PlatformEventRequest* req;
1412 *dataLen = 0;
1413
1414 if ((paraLen < selSystemEventSizeWith1Bytes) ||
1415 (paraLen > selSystemEventSizeWith3Bytes))
1416 {
1417 return IPMI_CC_REQ_DATA_LEN_INVALID;
1418 }
1419
1420 if (isFromSystemChannel())
1421 { // first byte for SYSTEM Interface is Generator ID
1422 // +1 to get common struct
1423 req = reinterpret_cast<PlatformEventRequest*>((uint8_t*)request + 1);
1424 // Capture the generator ID
1425 generatorID = *reinterpret_cast<uint8_t*>(request);
1426 // Platform Event usually comes from other firmware, like BIOS.
1427 // Unlike BMC sensor, it does not have BMC DBUS sensor path.
1428 sensorPath = "System";
1429 }
1430 else
1431 {
1432 req = reinterpret_cast<PlatformEventRequest*>(request);
1433 // TODO GenratorID for IPMB is combination of RqSA and RqLUN
1434 generatorID = 0xff;
1435 sensorPath = "IPMB";
1436 }
1437 // Content of event data field depends on sensor class.
1438 // When data0 bit[5:4] is non-zero, valid data counts is 3.
1439 // When data0 bit[7:6] is non-zero, valid data counts is 2.
1440 if (((req->data[0] & byte3EnableMask) != 0 &&
1441 paraLen < selSystemEventSizeWith3Bytes) ||
1442 ((req->data[0] & byte2EnableMask) != 0 &&
1443 paraLen < selSystemEventSizeWith2Bytes))
1444 {
1445 return IPMI_CC_REQ_DATA_LEN_INVALID;
1446 }
1447
1448 // Count bytes of Event Data
1449 if ((req->data[0] & byte3EnableMask) != 0)
1450 {
1451 count = 3;
1452 }
1453 else if ((req->data[0] & byte2EnableMask) != 0)
1454 {
1455 count = 2;
1456 }
1457 else
1458 {
1459 count = 1;
1460 }
1461 assert = req->eventDirectionType & directionMask ? false : true;
1462 std::vector<uint8_t> eventData(req->data, req->data + count);
1463
1464 sdbusplus::bus_t dbus(bus);
1465 std::string service =
1466 ipmi::getService(dbus, ipmiSELAddInterface, ipmiSELPath);
1467 sdbusplus::message_t writeSEL = dbus.new_method_call(
1468 service.c_str(), ipmiSELPath, ipmiSELAddInterface, "IpmiSelAdd");
1469 writeSEL.append(ipmiSELAddMessage, sensorPath, eventData, assert,
1470 generatorID);
1471 try
1472 {
1473 dbus.call(writeSEL);
1474 }
1475 catch (const sdbusplus::exception_t& e)
1476 {
1477 lg2::error("exception message: {ERROR}", "ERROR", e);
1478 return IPMI_CC_UNSPECIFIED_ERROR;
1479 }
1480 return IPMI_CC_OK;
1481 }
1482
register_netfn_sen_functions()1483 void register_netfn_sen_functions()
1484 {
1485 // Handlers with dbus-sdr handler implementation.
1486 // Do not register the hander if it dynamic sensors stack is used.
1487
1488 #ifndef FEATURE_DYNAMIC_SENSORS
1489
1490 #ifdef FEATURE_SENSORS_CACHE
1491 // Initialize the sensor matches
1492 initSensorMatches();
1493 #endif
1494
1495 // <Set Sensor Reading and Event Status>
1496 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1497 ipmi::sensor_event::cmdSetSensorReadingAndEvtSts,
1498 ipmi::Privilege::Operator, ipmiSetSensorReading);
1499 // <Get Sensor Reading>
1500 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1501 ipmi::sensor_event::cmdGetSensorReading,
1502 ipmi::Privilege::User, ipmiSensorGetSensorReading);
1503
1504 // <Reserve Device SDR Repository>
1505 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1506 ipmi::sensor_event::cmdReserveDeviceSdrRepository,
1507 ipmi::Privilege::User, ipmiSensorReserveSdr);
1508
1509 // <Get Device SDR Info>
1510 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1511 ipmi::sensor_event::cmdGetDeviceSdrInfo,
1512 ipmi::Privilege::User, ipmiSensorGetDeviceSdrInfo);
1513
1514 // <Get Sensor Thresholds>
1515 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1516 ipmi::sensor_event::cmdGetSensorThreshold,
1517 ipmi::Privilege::User, ipmiSensorGetSensorThresholds);
1518
1519 // <Set Sensor Thresholds>
1520 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1521 ipmi::sensor_event::cmdSetSensorThreshold,
1522 ipmi::Privilege::User, ipmiSenSetSensorThresholds);
1523
1524 // <Get Device SDR>
1525 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_DEVICE_SDR, nullptr,
1526 ipmi_sen_get_sdr, PRIVILEGE_USER);
1527
1528 #endif
1529
1530 // Common Handers used by both implementation.
1531
1532 // <Platform Event Message>
1533 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_PLATFORM_EVENT, nullptr,
1534 ipmicmdPlatformEvent, PRIVILEGE_OPERATOR);
1535
1536 // <Get Sensor Type>
1537 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1538 ipmi::sensor_event::cmdGetSensorType,
1539 ipmi::Privilege::User, ipmiGetSensorType);
1540
1541 return;
1542 }
1543