1 /*
2 // Copyright (c) 2018 Intel Corporation
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 */
16
17 #pragma once
18
19 #include <phosphor-logging/elog-errors.hpp>
20
21 #include <array>
22 #include <string>
23
24 static constexpr const char* mdrDefaultFile = "/var/lib/smbios/smbios2";
25
26 static constexpr uint16_t mdrSMBIOSSize = 32 * 1024;
27
28 constexpr uint16_t smbiosAgentId = 0x0101;
29 constexpr int firstAgentIndex = 1;
30
31 constexpr uint8_t maxDirEntries = 4;
32 constexpr uint32_t mdr2SMSize = 0x00100000;
33 constexpr uint32_t mdr2SMBaseAddress = 0x9FF00000;
34
35 constexpr uint8_t mdrDirVersion = 1;
36 constexpr uint8_t mdrTypeII = 2;
37
38 constexpr uint8_t mdr2Version = 2;
39 constexpr uint8_t smbiosAgentVersion = 1;
40 constexpr uint8_t smbiosDirVersion = 1;
41
42 constexpr uint32_t pageMask = 0xf000;
43 constexpr int smbiosDirIndex = 0;
44
45 constexpr uint32_t smbiosTableVersion = 15;
46 constexpr uint32_t smbiosTableTimestamp = 0x45464748;
47 constexpr uint32_t smbiosSMMemoryOffset = 0;
48 constexpr uint32_t smbiosSMMemorySize = 1024 * 1024;
49 constexpr uint32_t smbiosTableStorageSize = 64 * 1024;
50 constexpr uint32_t defaultTimeout = 2'000'000; // 2-seconds.
51
52 enum class MDR2SMBIOSStatusEnum
53 {
54 mdr2Init = 0,
55 mdr2Loaded = 1,
56 mdr2Updated = 2,
57 mdr2Updating = 3
58 };
59
60 enum class MDR2DirLockEnum
61 {
62 mdr2DirUnlock = 0,
63 mdr2DirLock = 1
64 };
65
66 enum class DirDataRequestEnum
67 {
68 dirDataNotRequested = 0x00,
69 dirDataRequested = 0x01
70 };
71
72 enum class FlagStatus
73 {
74 flagIsInvalid = 0,
75 flagIsValid = 1,
76 flagIsLocked = 2
77 };
78
79 typedef struct
80 {
81 uint8_t dataInfo[16];
82 } DataIdStruct;
83
84 typedef struct
85 {
86 DataIdStruct id;
87 uint32_t size;
88 uint32_t dataSetSize;
89 uint8_t dataVersion;
90 uint32_t timestamp;
91 } Mdr2DirEntry;
92
93 typedef struct
94 {
95 Mdr2DirEntry common;
96 MDR2SMBIOSStatusEnum stage;
97 MDR2DirLockEnum lock;
98 uint16_t lockHandle;
99 uint32_t xferBuff;
100 uint32_t xferSize;
101 uint32_t maxDataSize;
102 uint8_t* dataStorage;
103 } Mdr2DirLocalStruct;
104
105 typedef struct
106 {
107 uint8_t agentVersion;
108 uint8_t dirVersion;
109 uint8_t dirEntries;
110 uint8_t status; // valid / locked / etc
111 uint8_t remoteDirVersion;
112 uint16_t sessionHandle;
113 Mdr2DirLocalStruct dir[maxDirEntries];
114 } Mdr2DirStruct;
115
116 struct MDRSMBIOSHeader
117 {
118 uint8_t dirVer;
119 uint8_t mdrType;
120 uint32_t timestamp;
121 uint32_t dataSize;
122 } __attribute__((packed));
123
124 typedef struct
125 {
126 uint8_t majorVersion;
127 uint8_t minorVersion;
128 } SMBIOSVersion;
129
130 struct EntryPointStructure21
131 {
132 uint32_t anchorString;
133 uint8_t epChecksum;
134 uint8_t epLength;
135 SMBIOSVersion smbiosVersion;
136 uint16_t maxStructSize;
137 uint8_t epRevision;
138 uint8_t formattedArea[5];
139 uint8_t intermediateAnchorString[5];
140 uint8_t intermediateChecksum;
141 uint16_t structTableLength;
142 uint32_t structTableAddress;
143 uint16_t noOfSmbiosStruct;
144 uint8_t smbiosBDCRevision;
145 } __attribute__((packed));
146
147 struct EntryPointStructure30
148 {
149 uint8_t anchorString[5];
150 uint8_t epChecksum;
151 uint8_t epLength;
152 SMBIOSVersion smbiosVersion;
153 uint8_t smbiosDocRev;
154 uint8_t epRevision;
155 uint8_t reserved;
156 uint32_t structTableMaxSize;
157 uint64_t structTableAddr;
158 } __attribute__((packed));
159
160 struct StructureHeader
161 {
162 uint8_t type;
163 uint8_t length;
164 uint16_t handle;
165 } __attribute__((packed));
166
167 static constexpr const char* cpuSuffix = "/chassis/motherboard/cpu";
168
169 static constexpr const char* dimmSuffix = "/chassis/motherboard/dimm";
170
171 static constexpr const char* pcieSuffix = "/chassis/motherboard/pcieslot";
172
173 static constexpr const char* systemSuffix = "/chassis/motherboard/bios";
174
175 static constexpr const char* tpmSuffix = "/chassis/motherboard/tpm";
176
177 static constexpr const char* firmwarePath = "/xyz/openbmc_project/software";
178
179 static constexpr const char* defaultMotherboardPath =
180 "/xyz/openbmc_project/inventory/system/chassis/motherboard";
181
182 constexpr std::array<SMBIOSVersion, 8> supportedSMBIOSVersions{
183 SMBIOSVersion{3, 0}, SMBIOSVersion{3, 2}, SMBIOSVersion{3, 3},
184 SMBIOSVersion{3, 4}, SMBIOSVersion{3, 5}, SMBIOSVersion{3, 6},
185 SMBIOSVersion{3, 7}, SMBIOSVersion{3, 8}};
186
187 typedef enum
188 {
189 biosType = 0,
190 systemType = 1,
191 baseboardType = 2,
192 chassisType = 3,
193 processorsType = 4,
194 memoryControllerType = 5,
195 memoryModuleInformationType = 6,
196 cacheType = 7,
197 portConnectorType = 8,
198 systemSlots = 9,
199 onBoardDevicesType = 10,
200 oemStringsType = 11,
201 systemCconfigurationOptionsType = 12,
202 biosLanguageType = 13,
203 groupAssociatonsType = 14,
204 systemEventLogType = 15,
205 physicalMemoryArrayType = 16,
206 memoryDeviceType = 17,
207 systemPowerSupply = 39,
208 onboardDevicesExtended = 41,
209 tpmDeviceType = 43,
210 firmwareInventoryInformationType = 45,
211 } SmbiosType;
212
213 static constexpr uint8_t separateLen = 2;
214
smbiosNextPtr(uint8_t * smbiosDataIn)215 static inline uint8_t* smbiosNextPtr(uint8_t* smbiosDataIn)
216 {
217 if (smbiosDataIn == nullptr)
218 {
219 return nullptr;
220 }
221 uint8_t* smbiosData = smbiosDataIn + *(smbiosDataIn + 1);
222 int len = 0;
223 while ((*smbiosData | *(smbiosData + 1)) != 0)
224 {
225 smbiosData++;
226 len++;
227 if (len >= mdrSMBIOSSize) // To avoid endless loop
228 {
229 return nullptr;
230 }
231 }
232 return smbiosData + separateLen;
233 }
234
235 // When first time run getSMBIOSTypePtr, need to send the RegionS[].regionData
236 // to smbiosDataIn
getSMBIOSTypePtr(uint8_t * smbiosDataIn,uint8_t typeId,size_t size=0)237 static inline uint8_t* getSMBIOSTypePtr(uint8_t* smbiosDataIn, uint8_t typeId,
238 size_t size = 0)
239 {
240 if (smbiosDataIn == nullptr)
241 {
242 return nullptr;
243 }
244 char* smbiosData = reinterpret_cast<char*>(smbiosDataIn);
245 while ((*smbiosData != '\0') || (*(smbiosData + 1) != '\0'))
246 {
247 uint32_t len = *(smbiosData + 1);
248 if (*smbiosData != typeId)
249 {
250 smbiosData += len;
251 while ((*smbiosData != '\0') || (*(smbiosData + 1) != '\0'))
252 {
253 smbiosData++;
254 len++;
255 if (len >= mdrSMBIOSSize) // To avoid endless loop
256 {
257 return nullptr;
258 }
259 }
260 smbiosData += separateLen;
261 continue;
262 }
263 if (len < size)
264 {
265 phosphor::logging::log<phosphor::logging::level::ERR>(
266 "Record size mismatch!");
267 return nullptr;
268 }
269 return reinterpret_cast<uint8_t*>(smbiosData);
270 }
271 return nullptr;
272 }
273
smbiosSkipEntryPoint(uint8_t * smbiosDataIn)274 static inline uint8_t* smbiosSkipEntryPoint(uint8_t* smbiosDataIn)
275 {
276 const std::string anchorString30 = "_SM3_";
277 if (smbiosDataIn == nullptr)
278 {
279 return nullptr;
280 }
281
282 // Jump to starting address of the SMBIOS Structure Table from Entry Point
283 auto anchor = reinterpret_cast<const char*>(smbiosDataIn);
284 if (std::string_view(anchor, anchorString30.length())
285 .compare(anchorString30) == 0)
286 {
287 auto epStructure =
288 reinterpret_cast<const EntryPointStructure30*>(smbiosDataIn);
289 if (epStructure->structTableAddr < mdrSMBIOSSize)
290 {
291 smbiosDataIn += epStructure->structTableAddr;
292 }
293 }
294
295 return smbiosDataIn;
296 }
297
smbiosHandlePtr(uint8_t * smbiosDataIn,uint16_t handle)298 static inline uint8_t* smbiosHandlePtr(uint8_t* smbiosDataIn, uint16_t handle)
299 {
300 auto ptr = smbiosSkipEntryPoint(smbiosDataIn);
301 struct StructureHeader* header;
302 while (ptr != nullptr)
303 {
304 header = reinterpret_cast<struct StructureHeader*>(ptr);
305 if (header->length < sizeof(StructureHeader))
306 {
307 return nullptr;
308 }
309
310 if (header->handle == handle)
311 {
312 return ptr;
313 }
314 ptr = smbiosNextPtr(ptr);
315 }
316 return nullptr;
317 }
318
positionToString(uint8_t positionNum,uint8_t structLen,uint8_t * dataIn)319 static inline std::string positionToString(uint8_t positionNum,
320 uint8_t structLen, uint8_t* dataIn)
321 {
322 if (dataIn == nullptr || positionNum == 0)
323 {
324 return "";
325 }
326 uint16_t limit = mdrSMBIOSSize; // set a limit to avoid endless loop
327
328 char* target = reinterpret_cast<char*>(dataIn + structLen);
329 if (target == nullptr)
330 {
331 return "";
332 }
333 for (uint8_t index = 1; index < positionNum; index++)
334 {
335 for (; *target != '\0'; target++)
336 {
337 limit--;
338 // When target = dataIn + structLen + limit,
339 // following target++ will be nullptr
340 if (limit < 1 || target == nullptr)
341 {
342 return "";
343 }
344 }
345 target++;
346 if (target == nullptr || *target == '\0')
347 {
348 return ""; // 0x00 0x00 means end of the entry.
349 }
350 }
351
352 std::string result = target;
353 return result;
354 }
355
getObjectPath(const std::string & smbiosInventoryPath,const std::string & motherboardPath,const std::string & suffix,const unsigned int & index)356 static inline std::string getObjectPath(
357 const std::string& smbiosInventoryPath,
358 [[maybe_unused]] const std::string& motherboardPath,
359 const std::string& suffix, const unsigned int& index)
360 {
361 std::string path = smbiosInventoryPath + suffix + std::to_string(index);
362 #ifdef CUSTOM_DBUS_PATH
363 if (!motherboardPath.empty() && path.starts_with(defaultMotherboardPath))
364 {
365 path.replace(0, strlen(defaultMotherboardPath), motherboardPath);
366 }
367 #endif
368 return path;
369 }
370