xref: /openbmc/fb-ipmi-oem/src/selcommands.cpp (revision 010dee04) 
1 /*
2  * Copyright (c)  2018 Intel Corporation.
3  * Copyright (c)  2018-present Facebook.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <boost/algorithm/string/join.hpp>
19 #include <boost/container/flat_map.hpp>
20 #include <ipmid/api.hpp>
21 #include <nlohmann/json.hpp>
22 #include <phosphor-logging/log.hpp>
23 #include <sdbusplus/message/types.hpp>
24 #include <sdbusplus/timer.hpp>
25 #include <storagecommands.hpp>
26 
27 #include <fstream>
28 #include <iostream>
29 #include <sstream>
30 
31 enum class MemErrType
32 {
33     memTrainErr = 0,
34     memPmicErr = 7
35 };
36 
37 enum class PostEvtType
38 {
39     pxeBootFail = 0,
40     httpBootFail = 6,
41     getCertFail = 7,
42     amdAblFail = 10
43 };
44 
45 enum class PcieEvtType
46 {
47     dpc = 0
48 };
49 
50 enum class MemEvtType
51 {
52     ppr = 0,
53     adddc = 5,
54     noDimm = 7
55 };
56 
57 //----------------------------------------------------------------------
58 // Platform specific functions for storing app data
59 //----------------------------------------------------------------------
60 
byteToStr(uint8_t byte)61 static std::string byteToStr(uint8_t byte)
62 {
63     std::stringstream ss;
64 
65     ss << std::hex << std::uppercase << std::setfill('0');
66     ss << std::setw(2) << (int)byte;
67 
68     return ss.str();
69 }
70 
toHexStr(std::vector<uint8_t> & bytes,std::string & hexStr)71 static void toHexStr(std::vector<uint8_t>& bytes, std::string& hexStr)
72 {
73     std::stringstream stream;
74     stream << std::hex << std::uppercase << std::setfill('0');
75     for (const uint8_t byte : bytes)
76     {
77         stream << std::setw(2) << static_cast<int>(byte);
78     }
79     hexStr = stream.str();
80 }
81 
fromHexStr(const std::string hexStr,std::vector<uint8_t> & data)82 static int fromHexStr(const std::string hexStr, std::vector<uint8_t>& data)
83 {
84     for (unsigned int i = 0; i < hexStr.size(); i += 2)
85     {
86         try
87         {
88             data.push_back(static_cast<uint8_t>(
89                 std::stoul(hexStr.substr(i, 2), nullptr, 16)));
90         }
91         catch (const std::invalid_argument& e)
92         {
93             phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
94             return -1;
95         }
96         catch (const std::out_of_range& e)
97         {
98             phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
99             return -1;
100         }
101     }
102     return 0;
103 }
104 
105 namespace fb_oem::ipmi::sel
106 {
107 
108 class SELData
109 {
110   private:
111     nlohmann::json selDataObj;
112 
flush()113     void flush()
114     {
115         std::ofstream file(SEL_JSON_DATA_FILE);
116         file << selDataObj;
117         file.close();
118     }
119 
init()120     void init()
121     {
122         selDataObj[KEY_SEL_VER] = 0x51;
123         selDataObj[KEY_SEL_COUNT] = 0;
124         selDataObj[KEY_ADD_TIME] = 0xFFFFFFFF;
125         selDataObj[KEY_ERASE_TIME] = 0xFFFFFFFF;
126         selDataObj[KEY_OPER_SUPP] = 0x02;
127         /* Spec indicates that more than 64kB is free */
128         selDataObj[KEY_FREE_SPACE] = 0xFFFF;
129     }
130 
131   public:
SELData()132     SELData()
133     {
134         /* Get App data stored in json file */
135         std::ifstream file(SEL_JSON_DATA_FILE);
136         if (file)
137         {
138             file >> selDataObj;
139             file.close();
140         }
141 
142         /* Initialize SelData object if no entries. */
143         if (selDataObj.find(KEY_SEL_COUNT) == selDataObj.end())
144         {
145             init();
146         }
147     }
148 
clear()149     int clear()
150     {
151         /* Clear the complete Sel Json object */
152         selDataObj.clear();
153         /* Reinitialize it with basic data */
154         init();
155         /* Save the erase time */
156         struct timespec selTime = {};
157         if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
158         {
159             return -1;
160         }
161         selDataObj[KEY_ERASE_TIME] = selTime.tv_sec;
162         flush();
163         return 0;
164     }
165 
getCount()166     uint32_t getCount()
167     {
168         return selDataObj[KEY_SEL_COUNT];
169     }
170 
getInfo(GetSELInfoData & info)171     void getInfo(GetSELInfoData& info)
172     {
173         info.selVersion = selDataObj[KEY_SEL_VER];
174         info.entries = selDataObj[KEY_SEL_COUNT];
175         info.freeSpace = selDataObj[KEY_FREE_SPACE];
176         info.addTimeStamp = selDataObj[KEY_ADD_TIME];
177         info.eraseTimeStamp = selDataObj[KEY_ERASE_TIME];
178         info.operationSupport = selDataObj[KEY_OPER_SUPP];
179     }
180 
getEntry(uint32_t index,std::string & rawStr)181     int getEntry(uint32_t index, std::string& rawStr)
182     {
183         std::stringstream ss;
184         ss << std::hex;
185         ss << std::setw(2) << std::setfill('0') << index;
186 
187         /* Check or the requested SEL Entry, if record is available */
188         if (selDataObj.find(ss.str()) == selDataObj.end())
189         {
190             return -1;
191         }
192 
193         rawStr = selDataObj[ss.str()][KEY_SEL_ENTRY_RAW];
194         return 0;
195     }
196 
addEntry(std::string keyStr)197     int addEntry(std::string keyStr)
198     {
199         struct timespec selTime = {};
200 
201         if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
202         {
203             return -1;
204         }
205 
206         selDataObj[KEY_ADD_TIME] = selTime.tv_sec;
207 
208         int selCount = selDataObj[KEY_SEL_COUNT];
209         selDataObj[KEY_SEL_COUNT] = ++selCount;
210 
211         std::stringstream ss;
212         ss << std::hex;
213         ss << std::setw(2) << std::setfill('0') << selCount;
214 
215         selDataObj[ss.str()][KEY_SEL_ENTRY_RAW] = keyStr;
216         flush();
217         return selCount;
218     }
219 };
220 
221 /*
222  * A Function to parse common SEL message, a helper function
223  * for parseStdSel.
224  *
225  * Note that this function __CANNOT__ be overridden.
226  * To add board specific routine, please override parseStdSel.
227  */
228 
229 /*Used by decoding ME event*/
230 std::vector<std::string> nmDomName = {
231     "Entire Platform",          "CPU Subsystem",
232     "Memory Subsystem",         "HW Protection",
233     "High Power I/O subsystem", "Unknown"};
234 
235 /* Default log message for unknown type */
logDefault(uint8_t *,std::string & errLog)236 static void logDefault(uint8_t*, std::string& errLog)
237 {
238     errLog = "Unknown";
239 }
240 
logSysEvent(uint8_t * data,std::string & errLog)241 static void logSysEvent(uint8_t* data, std::string& errLog)
242 {
243     if (data[0] == 0xE5)
244     {
245         errLog = "Cause of Time change - ";
246         switch (data[2])
247         {
248             case 0x00:
249                 errLog += "NTP";
250                 break;
251             case 0x01:
252                 errLog += "Host RTL";
253                 break;
254             case 0x02:
255                 errLog += "Set SEL time cmd";
256                 break;
257             case 0x03:
258                 errLog += "Set SEL time UTC offset cmd";
259                 break;
260             default:
261                 errLog += "Unknown";
262         }
263 
264         if (data[1] == 0x00)
265             errLog += " - First Time";
266         else if (data[1] == 0x80)
267             errLog += " - Second Time";
268     }
269     else
270     {
271         errLog = "Unknown";
272     }
273 }
274 
logThermalEvent(uint8_t * data,std::string & errLog)275 static void logThermalEvent(uint8_t* data, std::string& errLog)
276 {
277     if (data[0] == 0x1)
278     {
279         errLog = "Limit Exceeded";
280     }
281     else
282     {
283         errLog = "Unknown";
284     }
285 }
286 
logCritIrq(uint8_t * data,std::string & errLog)287 static void logCritIrq(uint8_t* data, std::string& errLog)
288 {
289     if (data[0] == 0x0)
290     {
291         errLog = "NMI / Diagnostic Interrupt";
292     }
293     else if (data[0] == 0x03)
294     {
295         errLog = "Software NMI";
296     }
297     else
298     {
299         errLog = "Unknown";
300     }
301 
302     /* TODO: Call add_cri_sel for CRITICAL_IRQ */
303 }
304 
logPostErr(uint8_t * data,std::string & errLog)305 static void logPostErr(uint8_t* data, std::string& errLog)
306 {
307     if ((data[0] & 0x0F) == 0x0)
308     {
309         errLog = "System Firmware Error";
310     }
311     else
312     {
313         errLog = "Unknown";
314     }
315 
316     if (((data[0] >> 6) & 0x03) == 0x3)
317     {
318         // TODO: Need to implement IPMI spec based Post Code
319         errLog += ", IPMI Post Code";
320     }
321     else if (((data[0] >> 6) & 0x03) == 0x2)
322     {
323         errLog += ", OEM Post Code 0x" + byteToStr(data[2]) +
324                   byteToStr(data[1]);
325 
326         switch ((data[2] << 8) | data[1])
327         {
328             case 0xA105:
329                 errLog += ", BMC Failed (No Response)";
330                 break;
331             case 0xA106:
332                 errLog += ", BMC Failed (Self Test Fail)";
333                 break;
334             case 0xA10A:
335                 errLog += ", System Firmware Corruption Detected";
336                 break;
337             case 0xA10B:
338                 errLog += ", TPM Self-Test FAIL Detected";
339         }
340     }
341 }
342 
logMchChkErr(uint8_t * data,std::string & errLog)343 static void logMchChkErr(uint8_t* data, std::string& errLog)
344 {
345     /* TODO: Call add_cri_sel for CRITICAL_IRQ */
346     if ((data[0] & 0x0F) == 0x0B)
347     {
348         errLog = "Uncorrectable";
349     }
350     else if ((data[0] & 0x0F) == 0x0C)
351     {
352         errLog = "Correctable";
353     }
354     else
355     {
356         errLog = "Unknown";
357     }
358 
359     errLog += ", Machine Check bank Number " + std::to_string(data[1]) +
360               ", CPU " + std::to_string(data[2] >> 5) + ", Core " +
361               std::to_string(data[2] & 0x1F);
362 }
363 
logPcieErr(uint8_t * data,std::string & errLog)364 static void logPcieErr(uint8_t* data, std::string& errLog)
365 {
366     std::stringstream tmp1, tmp2;
367     tmp1 << std::hex << std::uppercase << std::setfill('0');
368     tmp2 << std::hex << std::uppercase << std::setfill('0');
369     tmp1 << " (Bus " << std::setw(2) << (int)(data[2]) << " / Dev "
370          << std::setw(2) << (int)(data[1] >> 3) << " / Fun " << std::setw(2)
371          << (int)(data[1] & 0x7) << ")";
372 
373     switch (data[0] & 0xF)
374     {
375         case 0x4:
376             errLog = "PCI PERR" + tmp1.str();
377             break;
378         case 0x5:
379             errLog = "PCI SERR" + tmp1.str();
380             break;
381         case 0x7:
382             errLog = "Correctable" + tmp1.str();
383             break;
384         case 0x8:
385             errLog = "Uncorrectable" + tmp1.str();
386             break;
387         case 0xA:
388             errLog = "Bus Fatal" + tmp1.str();
389             break;
390         case 0xD:
391         {
392             uint32_t venId = (uint32_t)data[1] << 8 | (uint32_t)data[2];
393             tmp2 << "Vendor ID: 0x" << std::setw(4) << venId;
394             errLog = tmp2.str();
395         }
396         break;
397         case 0xE:
398         {
399             uint32_t devId = (uint32_t)data[1] << 8 | (uint32_t)data[2];
400             tmp2 << "Device ID: 0x" << std::setw(4) << devId;
401             errLog = tmp2.str();
402         }
403         break;
404         case 0xF:
405             tmp2 << "Error ID from downstream: 0x" << std::setw(2)
406                  << (int)(data[1]) << std::setw(2) << (int)(data[2]);
407             errLog = tmp2.str();
408             break;
409         default:
410             errLog = "Unknown";
411     }
412 }
413 
logIioErr(uint8_t * data,std::string & errLog)414 static void logIioErr(uint8_t* data, std::string& errLog)
415 {
416     std::vector<std::string> tmpStr = {
417         "IRP0", "IRP1", " IIO-Core", "VT-d", "Intel Quick Data",
418         "Misc", " DMA", "ITC",       "OTC",  "CI"};
419 
420     if ((data[0] & 0xF) == 0)
421     {
422         errLog += "CPU " + std::to_string(data[2] >> 5) + ", Error ID 0x" +
423                   byteToStr(data[1]) + " - ";
424 
425         if ((data[2] & 0xF) <= 0x9)
426         {
427             errLog += tmpStr[(data[2] & 0xF)];
428         }
429         else
430         {
431             errLog += "Reserved";
432         }
433     }
434     else
435     {
436         errLog = "Unknown";
437     }
438 }
439 
logMemErr(uint8_t * dataPtr,std::string & errLog)440 [[maybe_unused]] static void logMemErr(uint8_t* dataPtr, std::string& errLog)
441 {
442     uint8_t snrType = dataPtr[0];
443     uint8_t snrNum = dataPtr[1];
444     uint8_t* data = &(dataPtr[3]);
445 
446     /* TODO: add pal_add_cri_sel */
447 
448     if (snrNum == memoryEccError)
449     {
450         /* SEL from MEMORY_ECC_ERR Sensor */
451         switch (data[0] & 0x0F)
452         {
453             case 0x0:
454                 if (snrType == 0x0C)
455                 {
456                     errLog = "Correctable";
457                 }
458                 else if (snrType == 0x10)
459                 {
460                     errLog = "Correctable ECC error Logging Disabled";
461                 }
462                 break;
463             case 0x1:
464                 errLog = "Uncorrectable";
465                 break;
466             case 0x5:
467                 errLog = "Correctable ECC error Logging Limit Disabled";
468                 break;
469             default:
470                 errLog = "Unknown";
471         }
472     }
473     else if (snrNum == memoryErrLogDIS)
474     {
475         // SEL from MEMORY_ERR_LOG_DIS Sensor
476         if ((data[0] & 0x0F) == 0x0)
477         {
478             errLog = "Correctable Memory Error Logging Disabled";
479         }
480         else
481         {
482             errLog = "Unknown";
483         }
484     }
485     else
486     {
487         errLog = "Unknown";
488         return;
489     }
490 
491     /* Common routine for both MEM_ECC_ERR and MEMORY_ERR_LOG_DIS */
492 
493     errLog += " (DIMM " + byteToStr(data[2]) + ") Logical Rank " +
494               std::to_string(data[1] & 0x03);
495 
496     /* DIMM number (data[2]):
497      * Bit[7:5]: Socket number  (Range: 0-7)
498      * Bit[4:3]: Channel number (Range: 0-3)
499      * Bit[2:0]: DIMM number    (Range: 0-7)
500      */
501 
502     /* TODO: Verify these bits */
503     std::string cpuStr = "CPU# " + std::to_string((data[2] & 0xE0) >> 5);
504     std::string chStr = "CHN# " + std::to_string((data[2] & 0x18) >> 3);
505     std::string dimmStr = "DIMM#" + std::to_string(data[2] & 0x7);
506 
507     switch ((data[1] & 0xC) >> 2)
508     {
509         case 0x0:
510         {
511             /* All Info Valid */
512             [[maybe_unused]] uint8_t chnNum = (data[2] & 0x1C) >> 2;
513             [[maybe_unused]] uint8_t dimmNum = data[2] & 0x3;
514 
515             /* TODO: If critical SEL logging is available, do it */
516             if (snrType == 0x0C)
517             {
518                 if ((data[0] & 0x0F) == 0x0)
519                 {
520                     /* TODO: add_cri_sel */
521                     /* "DIMM"+ 'A'+ chnNum + dimmNum + " ECC err,FRU:1"
522                      */
523                 }
524                 else if ((data[0] & 0x0F) == 0x1)
525                 {
526                     /* TODO: add_cri_sel */
527                     /* "DIMM"+ 'A'+ chnNum + dimmNum + " UECC err,FRU:1"
528                      */
529                 }
530             }
531             /* Continue to parse the error into a string. All Info Valid
532              */
533             errLog += " (" + cpuStr + ", " + chStr + ", " + dimmStr + ")";
534         }
535 
536         break;
537         case 0x1:
538 
539             /* DIMM info not valid */
540             errLog += " (" + cpuStr + ", " + chStr + ")";
541             break;
542         case 0x2:
543 
544             /* CHN info not valid */
545             errLog += " (" + cpuStr + ", " + dimmStr + ")";
546             break;
547         case 0x3:
548 
549             /* CPU info not valid */
550             errLog += " (" + chStr + ", " + dimmStr + ")";
551             break;
552     }
553 }
554 
logPwrErr(uint8_t * data,std::string & errLog)555 static void logPwrErr(uint8_t* data, std::string& errLog)
556 {
557     if (data[0] == 0x1)
558     {
559         errLog = "SYS_PWROK failure";
560         /* Also try logging to Critical log file, if available */
561         /* "SYS_PWROK failure,FRU:1" */
562     }
563     else if (data[0] == 0x2)
564     {
565         errLog = "PCH_PWROK failure";
566         /* Also try logging to Critical log file, if available */
567         /* "PCH_PWROK failure,FRU:1" */
568     }
569     else
570     {
571         errLog = "Unknown";
572     }
573 }
574 
logCatErr(uint8_t * data,std::string & errLog)575 static void logCatErr(uint8_t* data, std::string& errLog)
576 {
577     if (data[0] == 0x0)
578     {
579         errLog = "IERR/CATERR";
580         /* Also try logging to Critical log file, if available */
581         /* "IERR,FRU:1 */
582     }
583     else if (data[0] == 0xB)
584     {
585         errLog = "MCERR/CATERR";
586         /* Also try logging to Critical log file, if available */
587         /* "MCERR,FRU:1 */
588     }
589     else
590     {
591         errLog = "Unknown";
592     }
593 }
594 
logDimmHot(uint8_t * data,std::string & errLog)595 static void logDimmHot(uint8_t* data, std::string& errLog)
596 {
597     if ((data[0] << 16 | data[1] << 8 | data[2]) == 0x01FFFF)
598     {
599         errLog = "SOC MEMHOT";
600     }
601     else
602     {
603         errLog = "Unknown";
604         /* Also try logging to Critical log file, if available */
605         /* ""CPU_DIMM_HOT %s,FRU:1" */
606     }
607 }
608 
logSwNMI(uint8_t * data,std::string & errLog)609 static void logSwNMI(uint8_t* data, std::string& errLog)
610 {
611     if ((data[0] << 16 | data[1] << 8 | data[2]) == 0x03FFFF)
612     {
613         errLog = "Software NMI";
614     }
615     else
616     {
617         errLog = "Unknown SW NMI";
618     }
619 }
620 
logCPUThermalSts(uint8_t * data,std::string & errLog)621 static void logCPUThermalSts(uint8_t* data, std::string& errLog)
622 {
623     switch (data[0])
624     {
625         case 0x0:
626             errLog = "CPU Critical Temperature";
627             break;
628         case 0x1:
629             errLog = "PROCHOT#";
630             break;
631         case 0x2:
632             errLog = "TCC Activation";
633             break;
634         default:
635             errLog = "Unknown";
636     }
637 }
638 
logMEPwrState(uint8_t * data,std::string & errLog)639 static void logMEPwrState(uint8_t* data, std::string& errLog)
640 {
641     switch (data[0])
642     {
643         case 0:
644             errLog = "RUNNING";
645             break;
646         case 2:
647             errLog = "POWER_OFF";
648             break;
649         default:
650             errLog = "Unknown[" + std::to_string(data[0]) + "]";
651             break;
652     }
653 }
654 
logSPSFwHealth(uint8_t * data,std::string & errLog)655 static void logSPSFwHealth(uint8_t* data, std::string& errLog)
656 {
657     if ((data[0] & 0x0F) == 0x00)
658     {
659         const std::vector<std::string> tmpStr = {
660             "Recovery GPIO forced",
661             "Image execution failed",
662             "Flash erase error",
663             "Flash state information",
664             "Internal error",
665             "BMC did not respond",
666             "Direct Flash update",
667             "Manufacturing error",
668             "Automatic Restore to Factory Presets",
669             "Firmware Exception",
670             "Flash Wear-Out Protection Warning",
671             "Unknown",
672             "Unknown",
673             "DMI interface error",
674             "MCTP interface error",
675             "Auto-configuration finished",
676             "Unsupported Segment Defined Feature",
677             "Unknown",
678             "CPU Debug Capability Disabled",
679             "UMA operation error"};
680 
681         if (data[1] < 0x14)
682         {
683             errLog = tmpStr[data[1]];
684         }
685         else
686         {
687             errLog = "Unknown";
688         }
689     }
690     else if ((data[0] & 0x0F) == 0x01)
691     {
692         errLog = "SMBus link failure";
693     }
694     else
695     {
696         errLog = "Unknown";
697     }
698 }
699 
logNmExcA(uint8_t * data,std::string & errLog)700 static void logNmExcA(uint8_t* data, std::string& errLog)
701 {
702     /*NM4.0 #550710, Revision 1.95, and turn to p.155*/
703     if (data[0] == 0xA8)
704     {
705         errLog = "Policy Correction Time Exceeded";
706     }
707     else
708     {
709         errLog = "Unknown";
710     }
711 }
712 
logPCHThermal(uint8_t * data,std::string & errLog)713 static void logPCHThermal(uint8_t* data, std::string& errLog)
714 {
715     const std::vector<std::string> thresEvtName = {
716         "Lower Non-critical",
717         "Unknown",
718         "Lower Critical",
719         "Unknown",
720         "Lower Non-recoverable",
721         "Unknown",
722         "Unknown",
723         "Upper Non-critical",
724         "Unknown",
725         "Upper Critical",
726         "Unknown",
727         "Upper Non-recoverable"};
728 
729     if ((data[0] & 0x0f) < 12)
730     {
731         errLog = thresEvtName[(data[0] & 0x0f)];
732     }
733     else
734     {
735         errLog = "Unknown";
736     }
737 
738     errLog += ", curr_val: " + std::to_string(data[1]) +
739               " C, thresh_val: " + std::to_string(data[2]) + " C";
740 }
741 
logNmHealth(uint8_t * data,std::string & errLog)742 static void logNmHealth(uint8_t* data, std::string& errLog)
743 {
744     std::vector<std::string> nmErrType = {
745         "Unknown",
746         "Unknown",
747         "Unknown",
748         "Unknown",
749         "Unknown",
750         "Unknown",
751         "Unknown",
752         "Extended Telemetry Device Reading Failure",
753         "Outlet Temperature Reading Failure",
754         "Volumetric Airflow Reading Failure",
755         "Policy Misconfiguration",
756         "Power Sensor Reading Failure",
757         "Inlet Temperature Reading Failure",
758         "Host Communication Error",
759         "Real-time Clock Synchronization Failure",
760         "Platform Shutdown Initiated by Intel NM Policy",
761         "Unknown"};
762     uint8_t nmTypeIdx = (data[0] & 0xf);
763     uint8_t domIdx = (data[1] & 0xf);
764     uint8_t errIdx = ((data[1] >> 4) & 0xf);
765 
766     if (nmTypeIdx == 2)
767     {
768         errLog = "SensorIntelNM";
769     }
770     else
771     {
772         errLog = "Unknown";
773     }
774 
775     errLog += ", Domain:" + nmDomName[domIdx] + ", ErrType:" +
776               nmErrType[errIdx] + ", Err:0x" + byteToStr(data[2]);
777 }
778 
logNmCap(uint8_t * data,std::string & errLog)779 static void logNmCap(uint8_t* data, std::string& errLog)
780 {
781     const std::vector<std::string> nmCapStsStr = {"Not Available", "Available"};
782     if (data[0] & 0x7) // BIT1=policy, BIT2=monitoring, BIT3=pwr
783                        // limit and the others are reserved
784     {
785         errLog = "PolicyInterface:" + nmCapStsStr[BIT(data[0], 0)] +
786                  ",Monitoring:" + nmCapStsStr[BIT(data[0], 1)] +
787                  ",PowerLimit:" + nmCapStsStr[BIT(data[0], 2)];
788     }
789     else
790     {
791         errLog = "Unknown";
792     }
793 }
794 
logNmThreshold(uint8_t * data,std::string & errLog)795 static void logNmThreshold(uint8_t* data, std::string& errLog)
796 {
797     uint8_t thresNum = (data[0] & 0x3);
798     uint8_t domIdx = (data[1] & 0xf);
799     uint8_t polId = data[2];
800     uint8_t polEvtIdx = BIT(data[0], 3);
801     const std::vector<std::string> polEvtStr = {
802         "Threshold Exceeded", "Policy Correction Time Exceeded"};
803 
804     errLog = "Threshold Number:" + std::to_string(thresNum) + "-" +
805              polEvtStr[polEvtIdx] + ", Domain:" + nmDomName[domIdx] +
806              ", PolicyID:0x" + byteToStr(polId);
807 }
808 
logPwrThreshold(uint8_t * data,std::string & errLog)809 static void logPwrThreshold(uint8_t* data, std::string& errLog)
810 {
811     if (data[0] == 0x00)
812     {
813         errLog = "Limit Not Exceeded";
814     }
815     else if (data[0] == 0x01)
816     {
817         errLog = "Limit Exceeded";
818     }
819     else
820     {
821         errLog = "Unknown";
822     }
823 }
824 
logMSMI(uint8_t * data,std::string & errLog)825 static void logMSMI(uint8_t* data, std::string& errLog)
826 {
827     if (data[0] == 0x0)
828     {
829         errLog = "IERR/MSMI";
830     }
831     else if (data[0] == 0x0B)
832     {
833         errLog = "MCERR/MSMI";
834     }
835     else
836     {
837         errLog = "Unknown";
838     }
839 }
840 
logHprWarn(uint8_t * data,std::string & errLog)841 static void logHprWarn(uint8_t* data, std::string& errLog)
842 {
843     if (data[2] == 0x01)
844     {
845         if (data[1] == 0xFF)
846         {
847             errLog = "Infinite Time";
848         }
849         else
850         {
851             errLog = std::to_string(data[1]) + " minutes";
852         }
853     }
854     else
855     {
856         errLog = "Unknown";
857     }
858 }
859 
860 static const boost::container::flat_map<
861     uint8_t,
862     std::pair<std::string, std::function<void(uint8_t*, std::string&)>>>
863     sensorNameTable = {
864         {0xE9, {"SYSTEM_EVENT", logSysEvent}},
865         {0x7D, {"THERM_THRESH_EVT", logThermalEvent}},
866         {0xAA, {"BUTTON", logDefault}},
867         {0xAB, {"POWER_STATE", logDefault}},
868         {0xEA, {"CRITICAL_IRQ", logCritIrq}},
869         {0x2B, {"POST_ERROR", logPostErr}},
870         {0x40, {"MACHINE_CHK_ERR", logMchChkErr}},
871         {0x41, {"PCIE_ERR", logPcieErr}},
872         {0x43, {"IIO_ERR", logIioErr}},
873         {0X63, {"MEMORY_ECC_ERR", logDefault}},
874         {0X87, {"MEMORY_ERR_LOG_DIS", logDefault}},
875         {0X51, {"PROCHOT_EXT", logDefault}},
876         {0X56, {"PWR_ERR", logPwrErr}},
877         {0xE6, {"CATERR_A", logCatErr}},
878         {0xEB, {"CATERR_B", logCatErr}},
879         {0xB3, {"CPU_DIMM_HOT", logDimmHot}},
880         {0x90, {"SOFTWARE_NMI", logSwNMI}},
881         {0x1C, {"CPU0_THERM_STATUS", logCPUThermalSts}},
882         {0x1D, {"CPU1_THERM_STATUS", logCPUThermalSts}},
883         {0x16, {"ME_POWER_STATE", logMEPwrState}},
884         {0x17, {"SPS_FW_HEALTH", logSPSFwHealth}},
885         {0x18, {"NM_EXCEPTION_A", logNmExcA}},
886         {0x08, {"PCH_THERM_THRESHOLD", logPCHThermal}},
887         {0x19, {"NM_HEALTH", logNmHealth}},
888         {0x1A, {"NM_CAPABILITIES", logNmCap}},
889         {0x1B, {"NM_THRESHOLD", logNmThreshold}},
890         {0x3B, {"PWR_THRESH_EVT", logPwrThreshold}},
891         {0xE7, {"MSMI", logMSMI}},
892         {0xC5, {"HPR_WARNING", logHprWarn}}};
893 
parseSelHelper(StdSELEntry * data,std::string & errStr)894 static void parseSelHelper(StdSELEntry* data, std::string& errStr)
895 {
896     /* Check if sensor type is OS_BOOT (0x1f) */
897     if (data->sensorType == 0x1F)
898     {
899         /* OS_BOOT used by OS */
900         switch (data->eventData1 & 0xF)
901         {
902             case 0x07:
903                 errStr = "Base OS/Hypervisor Installation started";
904                 break;
905             case 0x08:
906                 errStr = "Base OS/Hypervisor Installation completed";
907                 break;
908             case 0x09:
909                 errStr = "Base OS/Hypervisor Installation aborted";
910                 break;
911             case 0x0A:
912                 errStr = "Base OS/Hypervisor Installation failed";
913                 break;
914             default:
915                 errStr = "Unknown";
916         }
917         return;
918     }
919 
920     auto findSensorName = sensorNameTable.find(data->sensorNum);
921     if (findSensorName == sensorNameTable.end())
922     {
923         errStr = "Unknown";
924         return;
925     }
926     else
927     {
928         switch (data->sensorNum)
929         {
930             /* logMemErr function needs data from sensor type */
931             case memoryEccError:
932             case memoryErrLogDIS:
933                 findSensorName->second.second(&(data->sensorType), errStr);
934                 break;
935             /* Other sensor function needs only event data for parsing */
936             default:
937                 findSensorName->second.second(&(data->eventData1), errStr);
938         }
939     }
940 
941     if (((data->eventData3 & 0x80) >> 7) == 0)
942     {
943         errStr += " Assertion";
944     }
945     else
946     {
947         errStr += " Deassertion";
948     }
949 }
950 
parseDimmPhyloc(StdSELEntry * data,std::string & errStr)951 static void parseDimmPhyloc(StdSELEntry* data, std::string& errStr)
952 {
953     // Log when " All info available"
954     uint8_t chNum = (data->eventData3 & 0x18) >> 3;
955     uint8_t dimmNum = data->eventData3 & 0x7;
956     uint8_t rankNum = data->eventData2 & 0x03;
957     uint8_t nodeNum = (data->eventData3 & 0xE0) >> 5;
958 
959     if (chNum == 3 && dimmNum == 0)
960     {
961         errStr += " Node: " + std::to_string(nodeNum) + "," +
962                   " Card: " + std::to_string(chNum) + "," +
963                   " Module: " + std::to_string(dimmNum) + "," +
964                   " Rank Number: " + std::to_string(rankNum) + "," +
965                   "  Location: DIMM A0";
966     }
967     else if (chNum == 2 && dimmNum == 0)
968     {
969         errStr += " Node: " + std::to_string(nodeNum) + "," +
970                   " Card: " + std::to_string(chNum) + "," +
971                   " Module: " + std::to_string(dimmNum) + "," +
972                   " Rank Number: " + std::to_string(rankNum) + "," +
973                   " Location: DIMM B0";
974     }
975     else if (chNum == 4 && dimmNum == 0)
976     {
977         errStr += " Node: " + std::to_string(nodeNum) + "," +
978                   " Card: " + std::to_string(chNum) + "," +
979                   " Module: " + std::to_string(dimmNum) + "," +
980                   " Rank Number: " + std::to_string(rankNum) + "," +
981                   " Location: DIMM C0 ";
982     }
983     else if (chNum == 5 && dimmNum == 0)
984     {
985         errStr += " Node: " + std::to_string(nodeNum) + "," +
986                   " Card: " + std::to_string(chNum) + "," +
987                   " Module: " + std::to_string(dimmNum) + "," +
988                   " Rank Number: " + std::to_string(rankNum) + "," +
989                   " Location: DIMM D0";
990     }
991     else
992     {
993         errStr += " Node: " + std::to_string(nodeNum) + "," +
994                   " Card: " + std::to_string(chNum) + "," +
995                   " Module: " + std::to_string(dimmNum) + "," +
996                   " Rank Number: " + std::to_string(rankNum) + "," +
997                   " Location: DIMM Unknown";
998     }
999 }
1000 
parseStdSel(StdSELEntry * data,std::string & errStr)1001 static void parseStdSel(StdSELEntry* data, std::string& errStr)
1002 {
1003     std::stringstream tmpStream;
1004     tmpStream << std::hex << std::uppercase;
1005 
1006     /* TODO: add pal_add_cri_sel */
1007     switch (data->sensorNum)
1008     {
1009         case memoryEccError:
1010             switch (data->eventData1 & 0x0F)
1011             {
1012                 case 0x00:
1013                     errStr = "Correctable";
1014                     tmpStream << "DIMM" << std::setw(2) << std::setfill('0')
1015                               << data->eventData3 << " ECC err";
1016                     parseDimmPhyloc(data, errStr);
1017                     break;
1018                 case 0x01:
1019                     errStr = "Uncorrectable";
1020                     tmpStream << "DIMM" << std::setw(2) << std::setfill('0')
1021                               << data->eventData3 << " UECC err";
1022                     parseDimmPhyloc(data, errStr);
1023                     break;
1024                 case 0x02:
1025                     errStr = "Parity";
1026                     break;
1027                 case 0x05:
1028                     errStr = "Correctable ECC error Logging Limit Reached";
1029                     break;
1030                 default:
1031                     errStr = "Unknown";
1032             }
1033             break;
1034         case memoryErrLogDIS:
1035             if ((data->eventData1 & 0x0F) == 0)
1036             {
1037                 errStr = "Correctable Memory Error Logging Disabled";
1038             }
1039             else
1040             {
1041                 errStr = "Unknown";
1042             }
1043             break;
1044         default:
1045             parseSelHelper(data, errStr);
1046             return;
1047     }
1048 
1049     errStr += " (DIMM " + std::to_string(data->eventData3) + ")";
1050     errStr += " Logical Rank " + std::to_string(data->eventData2 & 0x03);
1051 
1052     switch ((data->eventData2 & 0x0C) >> 2)
1053     {
1054         case 0x00:
1055             // Ignore when " All info available"
1056             break;
1057         case 0x01:
1058             errStr += " DIMM info not valid";
1059             break;
1060         case 0x02:
1061             errStr += " CHN info not valid";
1062             break;
1063         case 0x03:
1064             errStr += " CPU info not valid";
1065             break;
1066         default:
1067             errStr += " Unknown";
1068     }
1069 
1070     if (((data->eventType & 0x80) >> 7) == 0)
1071     {
1072         errStr += " Assertion";
1073     }
1074     else
1075     {
1076         errStr += " Deassertion";
1077     }
1078 
1079     return;
1080 }
1081 
parseOemSel(TsOemSELEntry * data,std::string & errStr)1082 static void parseOemSel(TsOemSELEntry* data, std::string& errStr)
1083 {
1084     std::stringstream tmpStream;
1085     tmpStream << std::hex << std::uppercase << std::setfill('0');
1086 
1087     switch (data->recordType)
1088     {
1089         case 0xC0:
1090             tmpStream << "VID:0x" << std::setw(2) << (int)data->oemData[1]
1091                       << std::setw(2) << (int)data->oemData[0] << " DID:0x"
1092                       << std::setw(2) << (int)data->oemData[3] << std::setw(2)
1093                       << (int)data->oemData[2] << " Slot:0x" << std::setw(2)
1094                       << (int)data->oemData[4] << " Error ID:0x" << std::setw(2)
1095                       << (int)data->oemData[5];
1096             break;
1097         case 0xC2:
1098             tmpStream << "Extra info:0x" << std::setw(2)
1099                       << (int)data->oemData[1] << " MSCOD:0x" << std::setw(2)
1100                       << (int)data->oemData[3] << std::setw(2)
1101                       << (int)data->oemData[2] << " MCACOD:0x" << std::setw(2)
1102                       << (int)data->oemData[5] << std::setw(2)
1103                       << (int)data->oemData[4];
1104             break;
1105         case 0xC3:
1106             int bank = (data->oemData[1] & 0xf0) >> 4;
1107             int col = ((data->oemData[1] & 0x0f) << 8) | data->oemData[2];
1108 
1109             tmpStream << "Fail Device:0x" << std::setw(2)
1110                       << (int)data->oemData[0] << " Bank:0x" << std::setw(2)
1111                       << bank << " Column:0x" << std::setw(2) << col
1112                       << " Failed Row:0x" << std::setw(2)
1113                       << (int)data->oemData[3] << std::setw(2)
1114                       << (int)data->oemData[4] << std::setw(2)
1115                       << (int)data->oemData[5];
1116     }
1117 
1118     errStr = tmpStream.str();
1119 
1120     return;
1121 }
1122 
dimmLocationStr(uint8_t socket,uint8_t channel,uint8_t slot)1123 static std::string dimmLocationStr(uint8_t socket, uint8_t channel,
1124                                    uint8_t slot)
1125 {
1126     uint8_t sled = (socket >> 4) & 0x3;
1127 
1128     socket &= 0xf;
1129     if (channel == 0xFF && slot == 0xFF)
1130     {
1131         return std::format(
1132             "DIMM Slot Location: Sled {:02}/Socket {:02}, Channel unknown"
1133             ", Slot unknown, DIMM unknown",
1134             sled, socket);
1135     }
1136     else
1137     {
1138         channel &= 0xf;
1139         slot &= 0xf;
1140         const char label[] = {'A', 'C', 'B', 'D'};
1141         uint8_t idx = socket * 2 + slot;
1142         return std::format("DIMM Slot Location: Sled {:02}/Socket {:02}"
1143                            ", Channel {:02}, Slot {:02} DIMM {}",
1144                            sled, socket, channel, slot,
1145                            (idx < sizeof(label))
1146                                ? label[idx] + std::to_string(channel)
1147                                : "NA");
1148     }
1149 }
1150 
parseOemUnifiedSel(NtsOemSELEntry * data,std::string & errStr)1151 static void parseOemUnifiedSel(NtsOemSELEntry* data, std::string& errStr)
1152 {
1153     uint8_t* ptr = data->oemData;
1154     uint8_t eventType = ptr[5] & 0xf;
1155     int genInfo = ptr[0];
1156     int errType = genInfo & 0x0f;
1157     std::vector<std::string> dimmErr = {
1158         "Memory training failure",
1159         "Memory correctable error",
1160         "Memory uncorrectable error",
1161         "Memory correctable error (Patrol scrub)",
1162         "Memory uncorrectable error (Patrol scrub)",
1163         "Memory Parity Error (PCC=0)",
1164         "Memory Parity Error (PCC=1)",
1165         "Memory PMIC Error",
1166         "CXL Memory training error",
1167         "Reserved"};
1168     std::vector<std::string> postEvent = {
1169         "System PXE boot fail",
1170         "CMOS/NVRAM configuration cleared",
1171         "TPM Self-Test Fail",
1172         "Boot Drive failure",
1173         "Data Drive failure",
1174         "Received invalid boot order request from BMC",
1175         "System HTTP boot fail",
1176         "BIOS fails to get the certificate from BMC",
1177         "Password cleared by jumper",
1178         "DXE FV check failure",
1179         "AMD ABL failure",
1180         "Reserved"};
1181     std::vector<std::string> certErr = {
1182         "No certificate at BMC", "IPMI transaction fail",
1183         "Certificate data corrupted", "Reserved"};
1184     std::vector<std::string> pcieEvent = {
1185         "PCIe DPC Event",
1186         "PCIe LER Event",
1187         "PCIe Link Retraining and Recovery",
1188         "PCIe Link CRC Error Check and Retry",
1189         "PCIe Corrupt Data Containment",
1190         "PCIe Express ECRC",
1191         "Reserved"};
1192     std::vector<std::string> memEvent = {
1193         "Memory PPR event",
1194         "Memory Correctable Error logging limit reached",
1195         "Memory disable/map-out for FRB",
1196         "Memory SDDC",
1197         "Memory Address range/Partial mirroring",
1198         "Memory ADDDC",
1199         "Memory SMBus hang recovery",
1200         "No DIMM in System",
1201         "Reserved"};
1202     std::vector<std::string> memPprTime = {"Boot time", "Autonomous",
1203                                            "Run time", "Reserved"};
1204     std::vector<std::string> memPpr = {"PPR success", "PPR fail", "PPR request",
1205                                        "Reserved"};
1206     std::vector<std::string> memAdddc = {
1207         "Bank VLS", "r-Bank VLS + re-buddy", "r-Bank VLS + Rank VLS",
1208         "r-Rank VLS + re-buddy", "Reserved"};
1209     std::vector<std::string> pprEvent = {"PPR disable", "Soft PPR", "Hard PPR",
1210                                          "Reserved"};
1211 
1212     std::stringstream tmpStream;
1213 
1214     switch (errType)
1215     {
1216         case unifiedPcieErr:
1217             tmpStream << std::format(
1218                 "GeneralInfo: x86/PCIeErr(0x{:02X})"
1219                 ", Bus {:02X}/Dev {:02X}/Fun {:02X}, TotalErrID1Cnt: 0x{:04X}"
1220                 ", ErrID2: 0x{:02X}, ErrID1: 0x{:02X}",
1221                 genInfo, ptr[8], ptr[7] >> 3, ptr[7] & 0x7,
1222                 (ptr[10] << 8) | ptr[9], ptr[11], ptr[12]);
1223             break;
1224         case unifiedMemErr:
1225             eventType = ptr[9] & 0xf;
1226             tmpStream << std::format(
1227                 "GeneralInfo: MemErr(0x{:02X}), {}, DIMM Failure Event: {}",
1228                 genInfo, dimmLocationStr(ptr[5], ptr[6], ptr[7]),
1229                 dimmErr[std::min(eventType,
1230                                  static_cast<uint8_t>(dimmErr.size() - 1))]);
1231 
1232             if (static_cast<MemErrType>(eventType) == MemErrType::memTrainErr ||
1233                 static_cast<MemErrType>(eventType) == MemErrType::memPmicErr)
1234             {
1235                 bool amd = ptr[9] & 0x80;
1236                 tmpStream << std::format(
1237                     ", Major Code: 0x{:02X}, Minor Code: 0x{:0{}X}", ptr[10],
1238                     amd ? (ptr[12] << 8 | ptr[11]) : ptr[11], amd ? 4 : 2);
1239             }
1240             break;
1241         case unifiedIioErr:
1242             tmpStream << std::format(
1243                 "GeneralInfo: IIOErr(0x{:02X})"
1244                 ", IIO Port Location: Sled {:02}/Socket {:02}, Stack 0x{:02X}"
1245                 ", Error Type: 0x{:02X}, Error Severity: 0x{:02X}"
1246                 ", Error ID: 0x{:02X}",
1247                 genInfo, (ptr[5] >> 4) & 0x3, ptr[5] & 0xf, ptr[6], ptr[10],
1248                 ptr[11] & 0xf, ptr[12]);
1249             break;
1250         case unifiedPostEvt:
1251             tmpStream << std::format(
1252                 "GeneralInfo: POST(0x{:02X}), POST Failure Event: {}", genInfo,
1253                 postEvent[std::min(
1254                     eventType, static_cast<uint8_t>(postEvent.size() - 1))]);
1255 
1256             switch (static_cast<PostEvtType>(eventType))
1257             {
1258                 case PostEvtType::pxeBootFail:
1259                 case PostEvtType::httpBootFail:
1260                 {
1261                     uint8_t failType = ptr[10] & 0xf;
1262                     tmpStream
1263                         << std::format(", Fail Type: {}, Error Code: 0x{:02X}",
1264                                        (failType == 4 || failType == 6)
1265                                            ? std::format("IPv{} fail", failType)
1266                                            : std::format("0x{:02X}", ptr[10]),
1267                                        ptr[11]);
1268                     break;
1269                 }
1270                 case PostEvtType::getCertFail:
1271                     tmpStream << std::format(
1272                         ", Failure Detail: {}",
1273                         certErr[std::min(
1274                             ptr[9], static_cast<uint8_t>(certErr.size() - 1))]);
1275                     break;
1276                 case PostEvtType::amdAblFail:
1277                     tmpStream << std::format(", ABL Error Code: 0x{:04X}",
1278                                              (ptr[12] << 8) | ptr[11]);
1279                     break;
1280             }
1281             break;
1282         case unifiedPcieEvt:
1283             tmpStream << std::format(
1284                 "GeneralInfo: PCIeEvent(0x{:02X}), PCIe Failure Event: {}",
1285                 genInfo,
1286                 pcieEvent[std::min(
1287                     eventType, static_cast<uint8_t>(pcieEvent.size() - 1))]);
1288 
1289             if (static_cast<PcieEvtType>(eventType) == PcieEvtType::dpc)
1290             {
1291                 tmpStream << std::format(
1292                     ", Status: 0x{:04X}, Source ID: 0x{:04X}",
1293                     (ptr[8] << 8) | ptr[7], (ptr[10] << 8) | ptr[9]);
1294             }
1295             break;
1296         case unifiedMemEvt:
1297             eventType = ptr[9] & 0xf;
1298             tmpStream
1299                 << std::format("GeneralInfo: MemEvent(0x{:02X})", genInfo)
1300                 << (static_cast<MemEvtType>(eventType) != MemEvtType::noDimm
1301                         ? std::format(", {}",
1302                                       dimmLocationStr(ptr[5], ptr[6], ptr[7]))
1303                         : "")
1304                 << ", DIMM Failure Event: ";
1305 
1306             switch (static_cast<MemEvtType>(eventType))
1307             {
1308                 case MemEvtType::ppr:
1309                     tmpStream << std::format("{} {}",
1310                                              memPprTime[(ptr[10] >> 2) & 0x3],
1311                                              memPpr[ptr[10] & 0x3]);
1312                     break;
1313                 case MemEvtType::adddc:
1314                     tmpStream << std::format(
1315                         "{} {}",
1316                         memEvent[std::min(eventType, static_cast<uint8_t>(
1317                                                          memEvent.size() - 1))],
1318                         memAdddc[std::min(
1319                             static_cast<uint8_t>(ptr[11] & 0xf),
1320                             static_cast<uint8_t>(memAdddc.size() - 1))]);
1321                     break;
1322                 default:
1323                     tmpStream << std::format(
1324                         "{}", memEvent[std::min(
1325                                   eventType,
1326                                   static_cast<uint8_t>(memEvent.size() - 1))]);
1327                     break;
1328             }
1329             break;
1330         case unifiedBootGuard:
1331             tmpStream << std::format(
1332                 "GeneralInfo: Boot Guard ACM Failure Events(0x{:02X})"
1333                 ", Error Class: 0x{:02X}, Error Code: 0x{:02X}",
1334                 genInfo, ptr[9], ptr[10]);
1335             break;
1336         case unifiedPprEvt:
1337             tmpStream << std::format(
1338                 "GeneralInfo: PPREvent(0x{:02X}), {}"
1339                 ", DIMM Info: {:02X}{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}",
1340                 genInfo,
1341                 pprEvent[std::min(eventType,
1342                                   static_cast<uint8_t>(pprEvent.size() - 1))],
1343                 ptr[6], ptr[7], ptr[8], ptr[9], ptr[10], ptr[11], ptr[12]);
1344             break;
1345         default:
1346             std::vector<uint8_t> oemData(ptr, ptr + 13);
1347             std::string oemDataStr;
1348             toHexStr(oemData, oemDataStr);
1349             tmpStream << std::format("Undefined Error Type(0x{:02X}), Raw: {}",
1350                                      errType, oemDataStr);
1351     }
1352 
1353     errStr = tmpStream.str();
1354 
1355     return;
1356 }
1357 
parseSelData(uint8_t fruId,std::vector<uint8_t> & reqData,std::string & msgLog)1358 static void parseSelData(uint8_t fruId, std::vector<uint8_t>& reqData,
1359                          std::string& msgLog)
1360 {
1361     /* Get record type */
1362     int recType = reqData[2];
1363     std::string errType, errLog;
1364 
1365     uint8_t* ptr = NULL;
1366 
1367     std::stringstream recTypeStream;
1368     recTypeStream << std::hex << std::uppercase << std::setfill('0')
1369                   << std::setw(2) << recType;
1370 
1371     msgLog = "SEL Entry: FRU: " + std::to_string(fruId) + ", Record: ";
1372 
1373     if (recType == stdErrType)
1374     {
1375         StdSELEntry* data = reinterpret_cast<StdSELEntry*>(&reqData[0]);
1376         std::string sensorName;
1377 
1378         errType = stdErr;
1379         if (data->sensorType == 0x1F)
1380         {
1381             sensorName = "OS";
1382         }
1383         else
1384         {
1385             auto findSensorName = sensorNameTable.find(data->sensorNum);
1386             if (findSensorName == sensorNameTable.end())
1387             {
1388                 sensorName = "Unknown";
1389             }
1390             else
1391             {
1392                 sensorName = findSensorName->second.first;
1393             }
1394         }
1395 
1396         time_t timeStamp = static_cast<time_t>(data->timeStamp);
1397         std::string timeStr;
1398         std::tm ts;
1399         if (localtime_r(&timeStamp, &ts))
1400         {
1401             char buf[64];
1402             if (strftime(buf, sizeof(buf), "%c", &ts))
1403             {
1404                 timeStr = buf;
1405             }
1406         }
1407 
1408         parseStdSel(data, errLog);
1409         ptr = &(data->eventData1);
1410         std::vector<uint8_t> evtData(ptr, ptr + 3);
1411         std::string eventData;
1412         toHexStr(evtData, eventData);
1413 
1414         std::stringstream senNumStream;
1415         senNumStream << std::hex << std::uppercase << std::setfill('0')
1416                      << std::setw(2) << (int)(data->sensorNum);
1417 
1418         msgLog += errType + " (0x" + recTypeStream.str() +
1419                   "), Time: " + timeStr + ", Sensor: " + sensorName + " (0x" +
1420                   senNumStream.str() + "), Event Data: (" + eventData + ") " +
1421                   errLog;
1422     }
1423     else if ((recType >= oemTSErrTypeMin) && (recType <= oemTSErrTypeMax))
1424     {
1425         /* timestamped OEM SEL records */
1426         TsOemSELEntry* data = reinterpret_cast<TsOemSELEntry*>(&reqData[0]);
1427         ptr = data->mfrId;
1428         std::vector<uint8_t> mfrIdData(ptr, ptr + 3);
1429         std::string mfrIdStr;
1430         toHexStr(mfrIdData, mfrIdStr);
1431 
1432         ptr = data->oemData;
1433         std::vector<uint8_t> oemData(ptr, ptr + 6);
1434         std::string oemDataStr;
1435         toHexStr(oemData, oemDataStr);
1436 
1437         time_t timeStamp = static_cast<time_t>(data->timeStamp);
1438         std::string timeStr;
1439         std::tm ts;
1440         if (localtime_r(&timeStamp, &ts))
1441         {
1442             char buf[64];
1443             if (strftime(buf, sizeof(buf), "%c", &ts))
1444             {
1445                 timeStr = buf;
1446             }
1447         }
1448 
1449         errType = oemTSErr;
1450         parseOemSel(data, errLog);
1451 
1452         msgLog += errType + " (0x" + recTypeStream.str() +
1453                   "), Time: " + timeStr + ", MFG ID: " + mfrIdStr +
1454                   ", OEM Data: (" + oemDataStr + ") " + errLog;
1455     }
1456     else if (recType == fbUniErrType)
1457     {
1458         NtsOemSELEntry* data = reinterpret_cast<NtsOemSELEntry*>(&reqData[0]);
1459         errType = fbUniSELErr;
1460         parseOemUnifiedSel(data, errLog);
1461         msgLog += errType + " (0x" + recTypeStream.str() + "), " + errLog;
1462     }
1463     else if ((recType >= oemNTSErrTypeMin) && (recType <= oemNTSErrTypeMax))
1464     {
1465         /* Non timestamped OEM SEL records */
1466         NtsOemSELEntry* data = reinterpret_cast<NtsOemSELEntry*>(&reqData[0]);
1467         errType = oemNTSErr;
1468 
1469         ptr = data->oemData;
1470         std::vector<uint8_t> oemData(ptr, ptr + 13);
1471         std::string oemDataStr;
1472         toHexStr(oemData, oemDataStr);
1473 
1474         parseOemSel((TsOemSELEntry*)data, errLog);
1475         msgLog += errType + " (0x" + recTypeStream.str() + "), OEM Data: (" +
1476                   oemDataStr + ") " + errLog;
1477     }
1478     else
1479     {
1480         errType = unknownErr;
1481         toHexStr(reqData, errLog);
1482         msgLog += errType + " (0x" + recTypeStream.str() +
1483                   ") RawData: " + errLog;
1484     }
1485 }
1486 
1487 } // namespace fb_oem::ipmi::sel
1488 
1489 namespace ipmi
1490 {
1491 
1492 namespace storage
1493 {
1494 
1495 static void registerSELFunctions() __attribute__((constructor));
1496 static fb_oem::ipmi::sel::SELData selObj __attribute__((init_priority(101)));
1497 
1498 ipmi::RspType<uint8_t,  // SEL version
1499               uint16_t, // SEL entry count
1500               uint16_t, // free space
1501               uint32_t, // last add timestamp
1502               uint32_t, // last erase timestamp
1503               uint8_t>  // operation support
ipmiStorageGetSELInfo()1504     ipmiStorageGetSELInfo()
1505 {
1506     fb_oem::ipmi::sel::GetSELInfoData info;
1507 
1508     selObj.getInfo(info);
1509     return ipmi::responseSuccess(info.selVersion, info.entries, info.freeSpace,
1510                                  info.addTimeStamp, info.eraseTimeStamp,
1511                                  info.operationSupport);
1512 }
1513 
1514 ipmi::RspType<uint16_t, std::vector<uint8_t>>
ipmiStorageGetSELEntry(std::vector<uint8_t> data)1515     ipmiStorageGetSELEntry(std::vector<uint8_t> data)
1516 {
1517     if (data.size() != sizeof(fb_oem::ipmi::sel::GetSELEntryRequest))
1518     {
1519         return ipmi::responseReqDataLenInvalid();
1520     }
1521 
1522     fb_oem::ipmi::sel::GetSELEntryRequest* reqData =
1523         reinterpret_cast<fb_oem::ipmi::sel::GetSELEntryRequest*>(&data[0]);
1524 
1525     if (reqData->reservID != 0)
1526     {
1527         if (!checkSELReservation(reqData->reservID))
1528         {
1529             return ipmi::responseInvalidReservationId();
1530         }
1531     }
1532 
1533     uint16_t selCnt = selObj.getCount();
1534     if (selCnt == 0)
1535     {
1536         return ipmi::responseSensorInvalid();
1537     }
1538 
1539     /* If it is asked for first entry */
1540     if (reqData->recordID == fb_oem::ipmi::sel::firstEntry)
1541     {
1542         /* First Entry (0x0000) as per Spec */
1543         reqData->recordID = 1;
1544     }
1545     else if (reqData->recordID == fb_oem::ipmi::sel::lastEntry)
1546     {
1547         /* Last entry (0xFFFF) as per Spec */
1548         reqData->recordID = selCnt;
1549     }
1550 
1551     std::string ipmiRaw;
1552 
1553     if (selObj.getEntry(reqData->recordID, ipmiRaw) < 0)
1554     {
1555         return ipmi::responseSensorInvalid();
1556     }
1557 
1558     std::vector<uint8_t> recDataBytes;
1559     if (fromHexStr(ipmiRaw, recDataBytes) < 0)
1560     {
1561         return ipmi::responseUnspecifiedError();
1562     }
1563 
1564     /* Identify the next SEL record ID. If recordID is same as
1565      * total SeL count then next id should be last entry else
1566      * it should be incremented by 1 to current RecordID
1567      */
1568     uint16_t nextRecord;
1569     if (reqData->recordID == selCnt)
1570     {
1571         nextRecord = fb_oem::ipmi::sel::lastEntry;
1572     }
1573     else
1574     {
1575         nextRecord = reqData->recordID + 1;
1576     }
1577 
1578     if (reqData->readLen == fb_oem::ipmi::sel::entireRecord)
1579     {
1580         return ipmi::responseSuccess(nextRecord, recDataBytes);
1581     }
1582     else
1583     {
1584         if (reqData->offset >= fb_oem::ipmi::sel::selRecordSize ||
1585             reqData->readLen > fb_oem::ipmi::sel::selRecordSize)
1586         {
1587             return ipmi::responseUnspecifiedError();
1588         }
1589         std::vector<uint8_t> recPartData;
1590 
1591         auto diff = fb_oem::ipmi::sel::selRecordSize - reqData->offset;
1592         auto readLength = std::min(diff, static_cast<int>(reqData->readLen));
1593 
1594         for (int i = 0; i < readLength; i++)
1595         {
1596             recPartData.push_back(recDataBytes[i + reqData->offset]);
1597         }
1598         return ipmi::responseSuccess(nextRecord, recPartData);
1599     }
1600 }
1601 
1602 ipmi::RspType<uint16_t>
ipmiStorageAddSELEntry(ipmi::Context::ptr ctx,std::vector<uint8_t> data)1603     ipmiStorageAddSELEntry(ipmi::Context::ptr ctx, std::vector<uint8_t> data)
1604 {
1605     /* Per the IPMI spec, need to cancel any reservation when a
1606      * SEL entry is added
1607      */
1608     cancelSELReservation();
1609 
1610     if (data.size() != fb_oem::ipmi::sel::selRecordSize)
1611     {
1612         return ipmi::responseReqDataLenInvalid();
1613     }
1614 
1615     std::string ipmiRaw, logErr;
1616     toHexStr(data, ipmiRaw);
1617 
1618     /* Parse sel data and get an error log to be filed */
1619     fb_oem::ipmi::sel::parseSelData((ctx->hostIdx + 1), data, logErr);
1620 
1621     static const std::string openBMCMessageRegistryVersion("0.1");
1622     std::string messageID =
1623         "OpenBMC." + openBMCMessageRegistryVersion + ".SELEntryAdded";
1624 
1625     /* Log the Raw SEL message to the journal */
1626     std::string journalMsg = "SEL Entry Added: " + ipmiRaw;
1627 
1628     phosphor::logging::log<phosphor::logging::level::INFO>(
1629         journalMsg.c_str(),
1630         phosphor::logging::entry("IPMISEL_MESSAGE_ID=%s", messageID.c_str()),
1631         phosphor::logging::entry("IPMISEL_MESSAGE_ARGS=%s", logErr.c_str()));
1632 
1633     std::map<std::string, std::string> ad;
1634     std::string severity = "xyz.openbmc_project.Logging.Entry.Level.Critical";
1635     ad.emplace("IPMI_RAW", ipmiRaw);
1636 
1637     auto bus = sdbusplus::bus::new_default();
1638     auto reqMsg = bus.new_method_call(
1639         "xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
1640         "xyz.openbmc_project.Logging.Create", "Create");
1641     reqMsg.append(logErr, severity, ad);
1642 
1643     try
1644     {
1645         bus.call(reqMsg);
1646     }
1647     catch (sdbusplus::exception_t& e)
1648     {
1649         phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
1650     }
1651 
1652     int responseID = selObj.addEntry(ipmiRaw.c_str());
1653     if (responseID < 0)
1654     {
1655         return ipmi::responseUnspecifiedError();
1656     }
1657     return ipmi::responseSuccess((uint16_t)responseID);
1658 }
1659 
ipmiStorageClearSEL(uint16_t reservationID,const std::array<uint8_t,3> & clr,uint8_t eraseOperation)1660 ipmi::RspType<uint8_t> ipmiStorageClearSEL(uint16_t reservationID,
1661                                            const std::array<uint8_t, 3>& clr,
1662                                            uint8_t eraseOperation)
1663 {
1664     if (!checkSELReservation(reservationID))
1665     {
1666         return ipmi::responseInvalidReservationId();
1667     }
1668 
1669     static constexpr std::array<uint8_t, 3> clrExpected = {'C', 'L', 'R'};
1670     if (clr != clrExpected)
1671     {
1672         return ipmi::responseInvalidFieldRequest();
1673     }
1674 
1675     /* If there is no sel then return erase complete */
1676     if (selObj.getCount() == 0)
1677     {
1678         return ipmi::responseSuccess(fb_oem::ipmi::sel::eraseComplete);
1679     }
1680 
1681     /* Erasure status cannot be fetched, so always return erasure
1682      * status as `erase completed`.
1683      */
1684     if (eraseOperation == fb_oem::ipmi::sel::getEraseStatus)
1685     {
1686         return ipmi::responseSuccess(fb_oem::ipmi::sel::eraseComplete);
1687     }
1688 
1689     /* Check that initiate erase is correct */
1690     if (eraseOperation != fb_oem::ipmi::sel::initiateErase)
1691     {
1692         return ipmi::responseInvalidFieldRequest();
1693     }
1694 
1695     /* Per the IPMI spec, need to cancel any reservation when the
1696      * SEL is cleared
1697      */
1698     cancelSELReservation();
1699 
1700     /* Clear the complete Sel Json object */
1701     if (selObj.clear() < 0)
1702     {
1703         return ipmi::responseUnspecifiedError();
1704     }
1705 
1706     return ipmi::responseSuccess(fb_oem::ipmi::sel::eraseComplete);
1707 }
1708 
ipmiStorageGetSELTime()1709 ipmi::RspType<uint32_t> ipmiStorageGetSELTime()
1710 {
1711     struct timespec selTime = {};
1712 
1713     if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
1714     {
1715         return ipmi::responseUnspecifiedError();
1716     }
1717 
1718     return ipmi::responseSuccess(selTime.tv_sec);
1719 }
1720 
ipmiStorageSetSELTime(uint32_t)1721 ipmi::RspType<> ipmiStorageSetSELTime(uint32_t)
1722 {
1723     // Set SEL Time is not supported
1724     return ipmi::responseInvalidCommand();
1725 }
1726 
ipmiStorageGetSELTimeUtcOffset()1727 ipmi::RspType<uint16_t> ipmiStorageGetSELTimeUtcOffset()
1728 {
1729     /* TODO: For now, the SEL time stamp is based on UTC time,
1730      * so return 0x0000 as offset. Might need to change once
1731      * supporting zones in SEL time stamps
1732      */
1733 
1734     uint16_t utcOffset = 0x0000;
1735     return ipmi::responseSuccess(utcOffset);
1736 }
1737 
registerSELFunctions()1738 void registerSELFunctions()
1739 {
1740     // <Get SEL Info>
1741     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1742                           ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
1743                           ipmiStorageGetSELInfo);
1744 
1745     // <Get SEL Entry>
1746     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1747                           ipmi::storage::cmdGetSelEntry, ipmi::Privilege::User,
1748                           ipmiStorageGetSELEntry);
1749 
1750     // <Add SEL Entry>
1751     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1752                           ipmi::storage::cmdAddSelEntry,
1753                           ipmi::Privilege::Operator, ipmiStorageAddSELEntry);
1754 
1755     // <Clear SEL>
1756     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1757                           ipmi::storage::cmdClearSel, ipmi::Privilege::Operator,
1758                           ipmiStorageClearSEL);
1759 
1760     // <Get SEL Time>
1761     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1762                           ipmi::storage::cmdGetSelTime, ipmi::Privilege::User,
1763                           ipmiStorageGetSELTime);
1764 
1765     // <Set SEL Time>
1766     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1767                           ipmi::storage::cmdSetSelTime,
1768                           ipmi::Privilege::Operator, ipmiStorageSetSELTime);
1769 
1770     // <Get SEL Time UTC Offset>
1771     ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1772                           ipmi::storage::cmdGetSelTimeUtcOffset,
1773                           ipmi::Privilege::User,
1774                           ipmiStorageGetSELTimeUtcOffset);
1775 
1776     return;
1777 }
1778 
1779 } // namespace storage
1780 } // namespace ipmi
1781