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 
updateWarningThreshold(uint8_t lowerValue,uint8_t upperValue,get_sdr::GetSensorThresholdsResponse & resp)664 void updateWarningThreshold(uint8_t lowerValue, uint8_t upperValue,
665                             get_sdr::GetSensorThresholdsResponse& resp)
666 {
667     resp.lowerNonCritical = lowerValue;
668     resp.upperNonCritical = upperValue;
669     if (lowerValue)
670     {
671         resp.validMask |= static_cast<uint8_t>(
672             ipmi::sensor::ThresholdMask::NON_CRITICAL_LOW_MASK);
673     }
674 
675     if (upperValue)
676     {
677         resp.validMask |= static_cast<uint8_t>(
678             ipmi::sensor::ThresholdMask::NON_CRITICAL_HIGH_MASK);
679     }
680 }
681 
updateCriticalThreshold(uint8_t lowerValue,uint8_t upperValue,get_sdr::GetSensorThresholdsResponse & resp)682 void updateCriticalThreshold(uint8_t lowerValue, uint8_t upperValue,
683                              get_sdr::GetSensorThresholdsResponse& resp)
684 {
685     resp.lowerCritical = lowerValue;
686     resp.upperCritical = upperValue;
687     if (lowerValue)
688     {
689         resp.validMask |= static_cast<uint8_t>(
690             ipmi::sensor::ThresholdMask::CRITICAL_LOW_MASK);
691     }
692 
693     if (upperValue)
694     {
695         resp.validMask |= static_cast<uint8_t>(
696             ipmi::sensor::ThresholdMask::CRITICAL_HIGH_MASK);
697     }
698 }
699 
updateNonRecoverableThreshold(uint8_t lowerValue,uint8_t upperValue,get_sdr::GetSensorThresholdsResponse & resp)700 void updateNonRecoverableThreshold(uint8_t lowerValue, uint8_t upperValue,
701                                    get_sdr::GetSensorThresholdsResponse& resp)
702 {
703     resp.lowerNonRecoverable = lowerValue;
704     resp.upperNonRecoverable = upperValue;
705     if (lowerValue)
706     {
707         resp.validMask |= static_cast<uint8_t>(
708             ipmi::sensor::ThresholdMask::NON_RECOVERABLE_LOW_MASK);
709     }
710 
711     if (upperValue)
712     {
713         resp.validMask |= static_cast<uint8_t>(
714             ipmi::sensor::ThresholdMask::NON_RECOVERABLE_HIGH_MASK);
715     }
716 }
717 
718 get_sdr::GetSensorThresholdsResponse
getSensorThresholds(ipmi::Context::ptr & ctx,uint8_t sensorNum)719     getSensorThresholds(ipmi::Context::ptr& ctx, uint8_t sensorNum)
720 {
721     get_sdr::GetSensorThresholdsResponse resp{};
722     const auto iter = ipmi::sensor::sensors.find(sensorNum);
723     const auto info = iter->second;
724 
725     std::string service;
726     boost::system::error_code ec;
727     ec = ipmi::getService(ctx, info.sensorInterface, info.sensorPath, service);
728     if (ec)
729     {
730         return resp;
731     }
732 
733     int32_t minClamp;
734     int32_t maxClamp;
735     int32_t rawData;
736     constexpr uint8_t sensorUnitsSignedBits = 2 << 6;
737     constexpr uint8_t signedDataFormat = 0x80;
738     if ((info.sensorUnits1 & sensorUnitsSignedBits) == signedDataFormat)
739     {
740         minClamp = std::numeric_limits<int8_t>::lowest();
741         maxClamp = std::numeric_limits<int8_t>::max();
742     }
743     else
744     {
745         minClamp = std::numeric_limits<uint8_t>::lowest();
746         maxClamp = std::numeric_limits<uint8_t>::max();
747     }
748 
749     static std::vector<std::string> thresholdNames{"Warning", "Critical",
750                                                    "NonRecoverable"};
751 
752     for (const auto& thresholdName : thresholdNames)
753     {
754         std::string thresholdInterface =
755             "xyz.openbmc_project.Sensor.Threshold." + thresholdName;
756         std::string thresholdLow = thresholdName + "Low";
757         std::string thresholdHigh = thresholdName + "High";
758 
759         ipmi::PropertyMap thresholds;
760         ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
761                                         thresholdInterface, thresholds);
762         if (ec)
763         {
764             continue;
765         }
766 
767         double lowValue = ipmi::mappedVariant<double>(
768             thresholds, thresholdLow, std::numeric_limits<double>::quiet_NaN());
769         double highValue = ipmi::mappedVariant<double>(
770             thresholds, thresholdHigh,
771             std::numeric_limits<double>::quiet_NaN());
772 
773         uint8_t lowerValue = 0;
774         uint8_t upperValue = 0;
775         if (std::isfinite(lowValue))
776         {
777             lowValue *= std::pow(10, info.scale - info.exponentR);
778             rawData = round((lowValue - info.scaledOffset) / info.coefficientM);
779             lowerValue =
780                 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
781         }
782 
783         if (std::isfinite(highValue))
784         {
785             highValue *= std::pow(10, info.scale - info.exponentR);
786             rawData =
787                 round((highValue - info.scaledOffset) / info.coefficientM);
788             upperValue =
789                 static_cast<uint8_t>(std::clamp(rawData, minClamp, maxClamp));
790         }
791 
792         if (thresholdName == "Warning")
793         {
794             updateWarningThreshold(lowerValue, upperValue, resp);
795         }
796         else if (thresholdName == "Critical")
797         {
798             updateCriticalThreshold(lowerValue, upperValue, resp);
799         }
800         else if (thresholdName == "NonRecoverable")
801         {
802             updateNonRecoverableThreshold(lowerValue, upperValue, resp);
803         }
804     }
805 
806     return resp;
807 }
808 
809 /** @brief implements the get sensor thresholds command
810  *  @param ctx - IPMI context pointer
811  *  @param sensorNum - sensor number
812  *
813  *  @returns IPMI completion code plus response data
814  *   - validMask - threshold mask
815  *   - lower non-critical threshold - IPMI messaging state
816  *   - lower critical threshold - link authentication state
817  *   - lower non-recoverable threshold - callback state
818  *   - upper non-critical threshold
819  *   - upper critical
820  *   - upper non-recoverable
821  */
822 ipmi::RspType<uint8_t, // validMask
823               uint8_t, // lowerNonCritical
824               uint8_t, // lowerCritical
825               uint8_t, // lowerNonRecoverable
826               uint8_t, // upperNonCritical
827               uint8_t, // upperCritical
828               uint8_t  // upperNonRecoverable
829               >
ipmiSensorGetSensorThresholds(ipmi::Context::ptr & ctx,uint8_t sensorNum)830     ipmiSensorGetSensorThresholds(ipmi::Context::ptr& ctx, uint8_t sensorNum)
831 {
832     constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
833 
834     const auto iter = ipmi::sensor::sensors.find(sensorNum);
835     if (iter == ipmi::sensor::sensors.end())
836     {
837         return ipmi::responseSensorInvalid();
838     }
839 
840     const auto info = iter->second;
841 
842     // Proceed only if the sensor value interface is implemented.
843     if (info.propertyInterfaces.find(valueInterface) ==
844         info.propertyInterfaces.end())
845     {
846         // return with valid mask as 0
847         return ipmi::responseSuccess();
848     }
849 
850     auto it = sensorThresholdMap.find(sensorNum);
851     if (it == sensorThresholdMap.end())
852     {
853         auto resp = getSensorThresholds(ctx, sensorNum);
854         if (resp.validMask == 0)
855         {
856             return ipmi::responseSensorInvalid();
857         }
858         sensorThresholdMap[sensorNum] = std::move(resp);
859     }
860 
861     const auto& resp = sensorThresholdMap[sensorNum];
862 
863     return ipmi::responseSuccess(
864         resp.validMask, resp.lowerNonCritical, resp.lowerCritical,
865         resp.lowerNonRecoverable, resp.upperNonCritical, resp.upperCritical,
866         resp.upperNonRecoverable);
867 }
868 
869 /** @brief implements the Set Sensor threshold command
870  *  @param sensorNumber        - sensor number
871  *  @param lowerNonCriticalThreshMask
872  *  @param lowerCriticalThreshMask
873  *  @param lowerNonRecovThreshMask
874  *  @param upperNonCriticalThreshMask
875  *  @param upperCriticalThreshMask
876  *  @param upperNonRecovThreshMask
877  *  @param reserved
878  *  @param lowerNonCritical    - lower non-critical threshold
879  *  @param lowerCritical       - Lower critical threshold
880  *  @param lowerNonRecoverable - Lower non recovarable threshold
881  *  @param upperNonCritical    - Upper non-critical threshold
882  *  @param upperCritical       - Upper critical
883  *  @param upperNonRecoverable - Upper Non-recoverable
884  *
885  *  @returns IPMI completion code
886  */
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)887 ipmi::RspType<> ipmiSenSetSensorThresholds(
888     ipmi::Context::ptr& ctx, uint8_t sensorNum, bool lowerNonCriticalThreshMask,
889     bool lowerCriticalThreshMask, bool lowerNonRecovThreshMask,
890     bool upperNonCriticalThreshMask, bool upperCriticalThreshMask,
891     bool upperNonRecovThreshMask, uint2_t reserved, uint8_t lowerNonCritical,
892     uint8_t lowerCritical, uint8_t, uint8_t upperNonCritical,
893     uint8_t upperCritical, uint8_t)
894 {
895     if (reserved)
896     {
897         return ipmi::responseInvalidFieldRequest();
898     }
899 
900     // lower nc and upper nc not suppported on any sensor
901     if (lowerNonRecovThreshMask || upperNonRecovThreshMask)
902     {
903         return ipmi::responseInvalidFieldRequest();
904     }
905 
906     // if none of the threshold mask are set, nothing to do
907     if (!(lowerNonCriticalThreshMask | lowerCriticalThreshMask |
908           lowerNonRecovThreshMask | upperNonCriticalThreshMask |
909           upperCriticalThreshMask | upperNonRecovThreshMask))
910     {
911         return ipmi::responseSuccess();
912     }
913 
914     constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
915 
916     const auto iter = ipmi::sensor::sensors.find(sensorNum);
917     if (iter == ipmi::sensor::sensors.end())
918     {
919         return ipmi::responseSensorInvalid();
920     }
921 
922     const auto& info = iter->second;
923 
924     // Proceed only if the sensor value interface is implemented.
925     if (info.propertyInterfaces.find(valueInterface) ==
926         info.propertyInterfaces.end())
927     {
928         // return with valid mask as 0
929         return ipmi::responseSuccess();
930     }
931 
932     constexpr auto warningThreshIntf =
933         "xyz.openbmc_project.Sensor.Threshold.Warning";
934     constexpr auto criticalThreshIntf =
935         "xyz.openbmc_project.Sensor.Threshold.Critical";
936 
937     std::string service;
938     boost::system::error_code ec;
939     ec = ipmi::getService(ctx, info.sensorInterface, info.sensorPath, service);
940     if (ec)
941     {
942         return ipmi::responseResponseError();
943     }
944     // store a vector of property name, value to set, and interface
945     std::vector<std::tuple<std::string, uint8_t, std::string>> thresholdsToSet;
946 
947     // define the indexes of the tuple
948     constexpr uint8_t propertyName = 0;
949     constexpr uint8_t thresholdValue = 1;
950     constexpr uint8_t interface = 2;
951     // verifiy all needed fields are present
952     if (lowerCriticalThreshMask || upperCriticalThreshMask)
953     {
954         ipmi::PropertyMap findThreshold;
955         ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
956                                         criticalThreshIntf, findThreshold);
957 
958         if (!ec)
959         {
960             if (lowerCriticalThreshMask)
961             {
962                 auto findLower = findThreshold.find("CriticalLow");
963                 if (findLower == findThreshold.end())
964                 {
965                     return ipmi::responseInvalidFieldRequest();
966                 }
967                 thresholdsToSet.emplace_back("CriticalLow", lowerCritical,
968                                              criticalThreshIntf);
969             }
970             if (upperCriticalThreshMask)
971             {
972                 auto findUpper = findThreshold.find("CriticalHigh");
973                 if (findUpper == findThreshold.end())
974                 {
975                     return ipmi::responseInvalidFieldRequest();
976                 }
977                 thresholdsToSet.emplace_back("CriticalHigh", upperCritical,
978                                              criticalThreshIntf);
979             }
980         }
981     }
982     if (lowerNonCriticalThreshMask || upperNonCriticalThreshMask)
983     {
984         ipmi::PropertyMap findThreshold;
985         ec = ipmi::getAllDbusProperties(ctx, service, info.sensorPath,
986                                         warningThreshIntf, findThreshold);
987 
988         if (!ec)
989         {
990             if (lowerNonCriticalThreshMask)
991             {
992                 auto findLower = findThreshold.find("WarningLow");
993                 if (findLower == findThreshold.end())
994                 {
995                     return ipmi::responseInvalidFieldRequest();
996                 }
997                 thresholdsToSet.emplace_back("WarningLow", lowerNonCritical,
998                                              warningThreshIntf);
999             }
1000             if (upperNonCriticalThreshMask)
1001             {
1002                 auto findUpper = findThreshold.find("WarningHigh");
1003                 if (findUpper == findThreshold.end())
1004                 {
1005                     return ipmi::responseInvalidFieldRequest();
1006                 }
1007                 thresholdsToSet.emplace_back("WarningHigh", upperNonCritical,
1008                                              warningThreshIntf);
1009             }
1010         }
1011     }
1012     for (const auto& property : thresholdsToSet)
1013     {
1014         // from section 36.3 in the IPMI Spec, assume all linear
1015         double valueToSet =
1016             ((info.coefficientM * std::get<thresholdValue>(property)) +
1017              (info.scaledOffset * std::pow(10.0, info.scale))) *
1018             std::pow(10.0, info.exponentR);
1019         ipmi::setDbusProperty(
1020             ctx, service, info.sensorPath, std::get<interface>(property),
1021             std::get<propertyName>(property), ipmi::Value(valueToSet));
1022     }
1023 
1024     // Invalidate the cache
1025     sensorThresholdMap.erase(sensorNum);
1026     return ipmi::responseSuccess();
1027 }
1028 
1029 /** @brief implements the get SDR Info command
1030  *  @param count - Operation
1031  *
1032  *  @returns IPMI completion code plus response data
1033  *   - sdrCount - sensor/SDR count
1034  *   - lunsAndDynamicPopulation - static/Dynamic sensor population flag
1035  */
1036 ipmi::RspType<uint8_t, // respcount
1037               uint8_t  // dynamic population flags
1038               >
ipmiSensorGetDeviceSdrInfo(std::optional<uint8_t> count)1039     ipmiSensorGetDeviceSdrInfo(std::optional<uint8_t> count)
1040 {
1041     uint8_t sdrCount;
1042     // multiple LUNs not supported.
1043     constexpr uint8_t lunsAndDynamicPopulation = 1;
1044     constexpr uint8_t getSdrCount = 0x01;
1045     constexpr uint8_t getSensorCount = 0x00;
1046 
1047     if (count.value_or(0) == getSdrCount)
1048     {
1049         // Get SDR count. This returns the total number of SDRs in the device.
1050         const auto& entityRecords =
1051             ipmi::sensor::EntityInfoMapContainer::getContainer()
1052                 ->getIpmiEntityRecords();
1053         sdrCount = ipmi::sensor::sensors.size() + frus.size() +
1054                    entityRecords.size();
1055     }
1056     else if (count.value_or(0) == getSensorCount)
1057     {
1058         // Get Sensor count. This returns the number of sensors
1059         sdrCount = ipmi::sensor::sensors.size();
1060     }
1061     else
1062     {
1063         return ipmi::responseInvalidCommandOnLun();
1064     }
1065 
1066     return ipmi::responseSuccess(sdrCount, lunsAndDynamicPopulation);
1067 }
1068 
1069 /** @brief implements the reserve SDR command
1070  *  @returns IPMI completion code plus response data
1071  *   - reservationID - reservation ID
1072  */
ipmiSensorReserveSdr()1073 ipmi::RspType<uint16_t> ipmiSensorReserveSdr()
1074 {
1075     // A constant reservation ID is okay until we implement add/remove SDR.
1076     constexpr uint16_t reservationID = 1;
1077 
1078     return ipmi::responseSuccess(reservationID);
1079 }
1080 
setUnitFieldsForObject(const ipmi::sensor::Info * info,get_sdr::SensorDataFullRecordBody * body)1081 void setUnitFieldsForObject(const ipmi::sensor::Info* info,
1082                             get_sdr::SensorDataFullRecordBody* body)
1083 {
1084     namespace server = sdbusplus::server::xyz::openbmc_project::sensor;
1085     try
1086     {
1087         auto unit = server::Value::convertUnitFromString(info->unit);
1088         // Unit strings defined in
1089         // phosphor-dbus-interfaces/xyz/openbmc_project/Sensor/Value.interface.yaml
1090         switch (unit)
1091         {
1092             case server::Value::Unit::DegreesC:
1093                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_DEGREES_C;
1094                 break;
1095             case server::Value::Unit::RPMS:
1096                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_RPM;
1097                 break;
1098             case server::Value::Unit::Volts:
1099                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_VOLTS;
1100                 break;
1101             case server::Value::Unit::Meters:
1102                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_METERS;
1103                 break;
1104             case server::Value::Unit::Amperes:
1105                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_AMPERES;
1106                 break;
1107             case server::Value::Unit::Joules:
1108                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_JOULES;
1109                 break;
1110             case server::Value::Unit::Watts:
1111                 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_WATTS;
1112                 break;
1113             default:
1114                 // Cannot be hit.
1115                 std::fprintf(stderr, "Unknown value unit type: = %s\n",
1116                              info->unit.c_str());
1117         }
1118     }
1119     catch (const sdbusplus::exception::InvalidEnumString& e)
1120     {
1121         lg2::warning("Warning: no unit provided for sensor!");
1122     }
1123 }
1124 
populate_record_from_dbus(get_sdr::SensorDataFullRecordBody * body,const ipmi::sensor::Info * info,ipmi_data_len_t)1125 ipmi_ret_t populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
1126                                      const ipmi::sensor::Info* info,
1127                                      ipmi_data_len_t)
1128 {
1129     /* Functional sensor case */
1130     if (isAnalogSensor(info->propertyInterfaces.begin()->first))
1131     {
1132         body->sensor_units_1 = info->sensorUnits1; // default is 0. unsigned, no
1133                                                    // rate, no modifier, not a %
1134         /* Unit info */
1135         setUnitFieldsForObject(info, body);
1136 
1137         get_sdr::body::set_b(info->coefficientB, body);
1138         get_sdr::body::set_m(info->coefficientM, body);
1139         get_sdr::body::set_b_exp(info->exponentB, body);
1140         get_sdr::body::set_r_exp(info->exponentR, body);
1141     }
1142 
1143     /* ID string */
1144     auto id_string = info->sensorName;
1145 
1146     if (id_string.empty())
1147     {
1148         id_string = info->sensorNameFunc(*info);
1149     }
1150 
1151     if (id_string.length() > FULL_RECORD_ID_STR_MAX_LENGTH)
1152     {
1153         get_sdr::body::set_id_strlen(FULL_RECORD_ID_STR_MAX_LENGTH, body);
1154     }
1155     else
1156     {
1157         get_sdr::body::set_id_strlen(id_string.length(), body);
1158     }
1159     get_sdr::body::set_id_type(3, body); // "8-bit ASCII + Latin 1"
1160     strncpy(body->id_string, id_string.c_str(),
1161             get_sdr::body::get_id_strlen(body));
1162 
1163     return IPMI_CC_OK;
1164 };
1165 
ipmi_fru_get_sdr(ipmi_request_t request,ipmi_response_t response,ipmi_data_len_t data_len)1166 ipmi_ret_t ipmi_fru_get_sdr(ipmi_request_t request, ipmi_response_t response,
1167                             ipmi_data_len_t data_len)
1168 {
1169     auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
1170     auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
1171     get_sdr::SensorDataFruRecord record{};
1172     auto dataLength = 0;
1173 
1174     auto fru = frus.begin();
1175     uint8_t fruID{};
1176     auto recordID = get_sdr::request::get_record_id(req);
1177 
1178     fruID = recordID - FRU_RECORD_ID_START;
1179     fru = frus.find(fruID);
1180     if (fru == frus.end())
1181     {
1182         return IPMI_CC_SENSOR_INVALID;
1183     }
1184 
1185     /* Header */
1186     get_sdr::header::set_record_id(recordID, &(record.header));
1187     record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
1188     record.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
1189     record.header.record_length = sizeof(record.key) + sizeof(record.body);
1190 
1191     /* Key */
1192     record.key.fruID = fruID;
1193     record.key.accessLun |= IPMI_LOGICAL_FRU;
1194     record.key.deviceAddress = BMCTargetAddress;
1195 
1196     /* Body */
1197     record.body.entityID = fru->second[0].entityID;
1198     record.body.entityInstance = fru->second[0].entityInstance;
1199     record.body.deviceType = fruInventoryDevice;
1200     record.body.deviceTypeModifier = IPMIFruInventory;
1201 
1202     /* Device ID string */
1203     auto deviceID =
1204         fru->second[0].path.substr(fru->second[0].path.find_last_of('/') + 1,
1205                                    fru->second[0].path.length());
1206 
1207     if (deviceID.length() > get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH)
1208     {
1209         get_sdr::body::set_device_id_strlen(
1210             get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH, &(record.body));
1211     }
1212     else
1213     {
1214         get_sdr::body::set_device_id_strlen(deviceID.length(), &(record.body));
1215     }
1216 
1217     strncpy(record.body.deviceID, deviceID.c_str(),
1218             get_sdr::body::get_device_id_strlen(&(record.body)));
1219 
1220     if (++fru == frus.end())
1221     {
1222         // we have reached till end of fru, so assign the next record id to
1223         // 512(Max fru ID = 511) + Entity Record ID(may start with 0).
1224         const auto& entityRecords =
1225             ipmi::sensor::EntityInfoMapContainer::getContainer()
1226                 ->getIpmiEntityRecords();
1227         auto next_record_id =
1228             (entityRecords.size())
1229                 ? entityRecords.begin()->first + ENTITY_RECORD_ID_START
1230                 : END_OF_RECORD;
1231         get_sdr::response::set_next_record_id(next_record_id, resp);
1232     }
1233     else
1234     {
1235         get_sdr::response::set_next_record_id(
1236             (FRU_RECORD_ID_START + fru->first), resp);
1237     }
1238 
1239     // Check for invalid offset size
1240     if (req->offset > sizeof(record))
1241     {
1242         return IPMI_CC_PARM_OUT_OF_RANGE;
1243     }
1244 
1245     dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
1246                           sizeof(record) - req->offset);
1247 
1248     std::memcpy(resp->record_data,
1249                 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
1250 
1251     *data_len = dataLength;
1252     *data_len += 2; // additional 2 bytes for next record ID
1253 
1254     return IPMI_CC_OK;
1255 }
1256 
ipmi_entity_get_sdr(ipmi_request_t request,ipmi_response_t response,ipmi_data_len_t data_len)1257 ipmi_ret_t ipmi_entity_get_sdr(ipmi_request_t request, ipmi_response_t response,
1258                                ipmi_data_len_t data_len)
1259 {
1260     auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
1261     auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
1262     get_sdr::SensorDataEntityRecord record{};
1263     auto dataLength = 0;
1264 
1265     const auto& entityRecords =
1266         ipmi::sensor::EntityInfoMapContainer::getContainer()
1267             ->getIpmiEntityRecords();
1268     auto entity = entityRecords.begin();
1269     uint8_t entityRecordID;
1270     auto recordID = get_sdr::request::get_record_id(req);
1271 
1272     entityRecordID = recordID - ENTITY_RECORD_ID_START;
1273     entity = entityRecords.find(entityRecordID);
1274     if (entity == entityRecords.end())
1275     {
1276         return IPMI_CC_SENSOR_INVALID;
1277     }
1278 
1279     /* Header */
1280     get_sdr::header::set_record_id(recordID, &(record.header));
1281     record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
1282     record.header.record_type = get_sdr::SENSOR_DATA_ENTITY_RECORD;
1283     record.header.record_length = sizeof(record.key) + sizeof(record.body);
1284 
1285     /* Key */
1286     record.key.containerEntityId = entity->second.containerEntityId;
1287     record.key.containerEntityInstance = entity->second.containerEntityInstance;
1288     get_sdr::key::set_flags(entity->second.isList, entity->second.isLinked,
1289                             &(record.key));
1290     record.key.entityId1 = entity->second.containedEntities[0].first;
1291     record.key.entityInstance1 = entity->second.containedEntities[0].second;
1292 
1293     /* Body */
1294     record.body.entityId2 = entity->second.containedEntities[1].first;
1295     record.body.entityInstance2 = entity->second.containedEntities[1].second;
1296     record.body.entityId3 = entity->second.containedEntities[2].first;
1297     record.body.entityInstance3 = entity->second.containedEntities[2].second;
1298     record.body.entityId4 = entity->second.containedEntities[3].first;
1299     record.body.entityInstance4 = entity->second.containedEntities[3].second;
1300 
1301     if (++entity == entityRecords.end())
1302     {
1303         get_sdr::response::set_next_record_id(END_OF_RECORD,
1304                                               resp); // last record
1305     }
1306     else
1307     {
1308         get_sdr::response::set_next_record_id(
1309             (ENTITY_RECORD_ID_START + entity->first), resp);
1310     }
1311 
1312     // Check for invalid offset size
1313     if (req->offset > sizeof(record))
1314     {
1315         return IPMI_CC_PARM_OUT_OF_RANGE;
1316     }
1317 
1318     dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
1319                           sizeof(record) - req->offset);
1320 
1321     std::memcpy(resp->record_data,
1322                 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
1323 
1324     *data_len = dataLength;
1325     *data_len += 2; // additional 2 bytes for next record ID
1326 
1327     return IPMI_CC_OK;
1328 }
1329 
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)1330 ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
1331                             ipmi_response_t response, ipmi_data_len_t data_len,
1332                             ipmi_context_t)
1333 {
1334     ipmi_ret_t ret = IPMI_CC_OK;
1335     get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
1336     get_sdr::GetSdrResp* resp = (get_sdr::GetSdrResp*)response;
1337 
1338     // Note: we use an iterator so we can provide the next ID at the end of
1339     // the call.
1340     auto sensor = ipmi::sensor::sensors.begin();
1341     auto recordID = get_sdr::request::get_record_id(req);
1342 
1343     // At the beginning of a scan, the host side will send us id=0.
1344     if (recordID != 0)
1345     {
1346         // recordID 0 to 255 means it is a FULL record.
1347         // recordID 256 to 511 means it is a FRU record.
1348         // recordID greater then 511 means it is a Entity Association
1349         // record. Currently we are supporting three record types: FULL
1350         // record, FRU record and Enttiy Association record.
1351         if (recordID >= ENTITY_RECORD_ID_START)
1352         {
1353             return ipmi_entity_get_sdr(request, response, data_len);
1354         }
1355         else if (recordID >= FRU_RECORD_ID_START &&
1356                  recordID < ENTITY_RECORD_ID_START)
1357         {
1358             return ipmi_fru_get_sdr(request, response, data_len);
1359         }
1360         else
1361         {
1362             sensor = ipmi::sensor::sensors.find(recordID);
1363             if (sensor == ipmi::sensor::sensors.end())
1364             {
1365                 return IPMI_CC_SENSOR_INVALID;
1366             }
1367         }
1368     }
1369 
1370     uint8_t sensor_id = sensor->first;
1371 
1372     auto it = sdrCacheMap.find(sensor_id);
1373     if (it == sdrCacheMap.end())
1374     {
1375         /* Header */
1376         get_sdr::SensorDataFullRecord record = {};
1377         get_sdr::header::set_record_id(sensor_id, &(record.header));
1378         record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
1379         record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
1380         record.header.record_length = sizeof(record.key) + sizeof(record.body);
1381 
1382         /* Key */
1383         get_sdr::key::set_owner_id_bmc(&(record.key));
1384         record.key.sensor_number = sensor_id;
1385 
1386         /* Body */
1387         record.body.entity_id = sensor->second.entityType;
1388         record.body.sensor_type = sensor->second.sensorType;
1389         record.body.event_reading_type = sensor->second.sensorReadingType;
1390         record.body.entity_instance = sensor->second.instance;
1391         if (ipmi::sensor::Mutability::Write ==
1392             (sensor->second.mutability & ipmi::sensor::Mutability::Write))
1393         {
1394             get_sdr::body::init_settable_state(true, &(record.body));
1395         }
1396 
1397         // Set the type-specific details given the DBus interface
1398         populate_record_from_dbus(&(record.body), &(sensor->second), data_len);
1399         sdrCacheMap[sensor_id] = std::move(record);
1400     }
1401 
1402     const auto& record = sdrCacheMap[sensor_id];
1403 
1404     if (++sensor == ipmi::sensor::sensors.end())
1405     {
1406         // we have reached till end of sensor, so assign the next record id
1407         // to 256(Max Sensor ID = 255) + FRU ID(may start with 0).
1408         auto next_record_id = (frus.size())
1409                                   ? frus.begin()->first + FRU_RECORD_ID_START
1410                                   : END_OF_RECORD;
1411 
1412         get_sdr::response::set_next_record_id(next_record_id, resp);
1413     }
1414     else
1415     {
1416         get_sdr::response::set_next_record_id(sensor->first, resp);
1417     }
1418 
1419     if (req->offset > sizeof(record))
1420     {
1421         return IPMI_CC_PARM_OUT_OF_RANGE;
1422     }
1423 
1424     // data_len will ultimately be the size of the record, plus
1425     // the size of the next record ID:
1426     *data_len = std::min(static_cast<size_t>(req->bytes_to_read),
1427                          sizeof(record) - req->offset);
1428 
1429     std::memcpy(resp->record_data,
1430                 reinterpret_cast<const uint8_t*>(&record) + req->offset,
1431                 *data_len);
1432 
1433     // data_len should include the LSB and MSB:
1434     *data_len += sizeof(resp->next_record_id_lsb) +
1435                  sizeof(resp->next_record_id_msb);
1436 
1437     return ret;
1438 }
1439 
isFromSystemChannel()1440 static bool isFromSystemChannel()
1441 {
1442     // TODO we could not figure out where the request is from based on IPMI
1443     // command handler parameters. because of it, we can not differentiate
1444     // request from SMS/SMM or IPMB channel
1445     return true;
1446 }
1447 
ipmicmdPlatformEvent(ipmi_netfn_t,ipmi_cmd_t,ipmi_request_t request,ipmi_response_t,ipmi_data_len_t dataLen,ipmi_context_t)1448 ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t, ipmi_cmd_t,
1449                                 ipmi_request_t request, ipmi_response_t,
1450                                 ipmi_data_len_t dataLen, ipmi_context_t)
1451 {
1452     uint16_t generatorID;
1453     size_t count;
1454     bool assert = true;
1455     std::string sensorPath;
1456     size_t paraLen = *dataLen;
1457     PlatformEventRequest* req;
1458     *dataLen = 0;
1459 
1460     if ((paraLen < selSystemEventSizeWith1Bytes) ||
1461         (paraLen > selSystemEventSizeWith3Bytes))
1462     {
1463         return IPMI_CC_REQ_DATA_LEN_INVALID;
1464     }
1465 
1466     if (isFromSystemChannel())
1467     { // first byte for SYSTEM Interface is Generator ID
1468         // +1 to get common struct
1469         req = reinterpret_cast<PlatformEventRequest*>((uint8_t*)request + 1);
1470         // Capture the generator ID
1471         generatorID = *reinterpret_cast<uint8_t*>(request);
1472         // Platform Event usually comes from other firmware, like BIOS.
1473         // Unlike BMC sensor, it does not have BMC DBUS sensor path.
1474         sensorPath = "System";
1475     }
1476     else
1477     {
1478         req = reinterpret_cast<PlatformEventRequest*>(request);
1479         // TODO GenratorID for IPMB is combination of RqSA and RqLUN
1480         generatorID = 0xff;
1481         sensorPath = "IPMB";
1482     }
1483     // Content of event data field depends on sensor class.
1484     // When data0 bit[5:4] is non-zero, valid data counts is 3.
1485     // When data0 bit[7:6] is non-zero, valid data counts is 2.
1486     if (((req->data[0] & byte3EnableMask) != 0 &&
1487          paraLen < selSystemEventSizeWith3Bytes) ||
1488         ((req->data[0] & byte2EnableMask) != 0 &&
1489          paraLen < selSystemEventSizeWith2Bytes))
1490     {
1491         return IPMI_CC_REQ_DATA_LEN_INVALID;
1492     }
1493 
1494     // Count bytes of Event Data
1495     if ((req->data[0] & byte3EnableMask) != 0)
1496     {
1497         count = 3;
1498     }
1499     else if ((req->data[0] & byte2EnableMask) != 0)
1500     {
1501         count = 2;
1502     }
1503     else
1504     {
1505         count = 1;
1506     }
1507     assert = req->eventDirectionType & directionMask ? false : true;
1508     std::vector<uint8_t> eventData(req->data, req->data + count);
1509 
1510     sdbusplus::bus_t dbus(bus);
1511     std::string service =
1512         ipmi::getService(dbus, ipmiSELAddInterface, ipmiSELPath);
1513     sdbusplus::message_t writeSEL = dbus.new_method_call(
1514         service.c_str(), ipmiSELPath, ipmiSELAddInterface, "IpmiSelAdd");
1515     writeSEL.append(ipmiSELAddMessage, sensorPath, eventData, assert,
1516                     generatorID);
1517     try
1518     {
1519         dbus.call(writeSEL);
1520     }
1521     catch (const sdbusplus::exception_t& e)
1522     {
1523         lg2::error("exception message: {ERROR}", "ERROR", e);
1524         return IPMI_CC_UNSPECIFIED_ERROR;
1525     }
1526     return IPMI_CC_OK;
1527 }
1528 
register_netfn_sen_functions()1529 void register_netfn_sen_functions()
1530 {
1531     // Handlers with dbus-sdr handler implementation.
1532     // Do not register the hander if it dynamic sensors stack is used.
1533 
1534 #ifndef FEATURE_DYNAMIC_SENSORS
1535 
1536 #ifdef FEATURE_SENSORS_CACHE
1537     // Initialize the sensor matches
1538     initSensorMatches();
1539 #endif
1540 
1541     // <Set Sensor Reading and Event Status>
1542     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1543                           ipmi::sensor_event::cmdSetSensorReadingAndEvtSts,
1544                           ipmi::Privilege::Operator, ipmiSetSensorReading);
1545     // <Get Sensor Reading>
1546     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1547                           ipmi::sensor_event::cmdGetSensorReading,
1548                           ipmi::Privilege::User, ipmiSensorGetSensorReading);
1549 
1550     // <Reserve Device SDR Repository>
1551     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1552                           ipmi::sensor_event::cmdReserveDeviceSdrRepository,
1553                           ipmi::Privilege::User, ipmiSensorReserveSdr);
1554 
1555     // <Get Device SDR Info>
1556     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1557                           ipmi::sensor_event::cmdGetDeviceSdrInfo,
1558                           ipmi::Privilege::User, ipmiSensorGetDeviceSdrInfo);
1559 
1560     // <Get Sensor Thresholds>
1561     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1562                           ipmi::sensor_event::cmdGetSensorThreshold,
1563                           ipmi::Privilege::User, ipmiSensorGetSensorThresholds);
1564 
1565     // <Set Sensor Thresholds>
1566     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1567                           ipmi::sensor_event::cmdSetSensorThreshold,
1568                           ipmi::Privilege::User, ipmiSenSetSensorThresholds);
1569 
1570     // <Get Device SDR>
1571     ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_DEVICE_SDR, nullptr,
1572                            ipmi_sen_get_sdr, PRIVILEGE_USER);
1573 
1574 #endif
1575 
1576     // Common Handers used by both implementation.
1577 
1578     // <Platform Event Message>
1579     ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_PLATFORM_EVENT, nullptr,
1580                            ipmicmdPlatformEvent, PRIVILEGE_OPERATOR);
1581 
1582     // <Get Sensor Type>
1583     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1584                           ipmi::sensor_event::cmdGetSensorType,
1585                           ipmi::Privilege::User, ipmiGetSensorType);
1586 
1587     return;
1588 }
1589