1 #include "terminus.hpp"
2
3 #include "dbus_impl_fru.hpp"
4 #include "terminus_manager.hpp"
5
6 #include <libpldm/platform.h>
7
8 #include <common/utils.hpp>
9
10 #include <ranges>
11
12 namespace pldm
13 {
14 namespace platform_mc
15 {
16
Terminus(pldm_tid_t tid,uint64_t supportedTypes,sdeventplus::Event & event)17 Terminus::Terminus(pldm_tid_t tid, uint64_t supportedTypes,
18 sdeventplus::Event& event) :
19 initialized(false), maxBufferSize(PLDM_PLATFORM_EVENT_MSG_MAX_BUFFER_SIZE),
20 synchronyConfigurationSupported(0), pollEvent(false), tid(tid),
21 supportedTypes(supportedTypes), event(event)
22 {}
23
doesSupportType(uint8_t type)24 bool Terminus::doesSupportType(uint8_t type)
25 {
26 return supportedTypes.test(type);
27 }
28
doesSupportCommand(uint8_t type,uint8_t command)29 bool Terminus::doesSupportCommand(uint8_t type, uint8_t command)
30 {
31 if (!doesSupportType(type))
32 {
33 return false;
34 }
35
36 try
37 {
38 const size_t idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (command / 8);
39 if (idx >= supportedCmds.size())
40 {
41 return false;
42 }
43
44 if (supportedCmds[idx] & (1 << (command % 8)))
45 {
46 lg2::info(
47 "PLDM type {TYPE} command {CMD} is supported by terminus {TID}",
48 "TYPE", type, "CMD", command, "TID", getTid());
49 return true;
50 }
51 }
52 catch (const std::exception& e)
53 {
54 return false;
55 }
56
57 return false;
58 }
59
findTerminusName()60 std::optional<std::string_view> Terminus::findTerminusName()
61 {
62 auto it = std::find_if(
63 entityAuxiliaryNamesTbl.begin(), entityAuxiliaryNamesTbl.end(),
64 [](const std::shared_ptr<EntityAuxiliaryNames>& entityAuxiliaryNames) {
65 const auto& [key, entityNames] = *entityAuxiliaryNames;
66 /**
67 * There is only one Overall system container entity in one
68 * terminus. The entity auxiliary name PDR of that terminus with the
69 * that type of containerID will include terminus name.
70 */
71 return (
72 entityAuxiliaryNames &&
73 key.containerId == PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID &&
74 entityNames.size());
75 });
76
77 if (it != entityAuxiliaryNamesTbl.end())
78 {
79 const auto& [key, entityNames] = **it;
80 if (!entityNames.size())
81 {
82 return std::nullopt;
83 }
84 return entityNames[0].second;
85 }
86
87 return std::nullopt;
88 }
89
createInventoryPath(std::string tName)90 bool Terminus::createInventoryPath(std::string tName)
91 {
92 if (tName.empty())
93 {
94 return false;
95 }
96
97 /* inventory object is created */
98 if (inventoryItemBoardInft)
99 {
100 return false;
101 }
102
103 inventoryPath = "/xyz/openbmc_project/inventory/system/board/" + tName;
104 try
105 {
106 inventoryItemBoardInft =
107 std::make_unique<pldm::dbus_api::PldmEntityReq>(
108 utils::DBusHandler::getBus(), inventoryPath.c_str());
109 return true;
110 }
111 catch (const sdbusplus::exception_t& e)
112 {
113 lg2::error(
114 "Failed to create Inventory Board interface for device {PATH}",
115 "PATH", inventoryPath);
116 }
117
118 return false;
119 }
120
parseTerminusPDRs()121 void Terminus::parseTerminusPDRs()
122 {
123 for (auto& pdr : pdrs)
124 {
125 auto pdrHdr = new (pdr.data()) pldm_pdr_hdr;
126 switch (pdrHdr->type)
127 {
128 case PLDM_SENSOR_AUXILIARY_NAMES_PDR:
129 {
130 auto sensorAuxNames = parseSensorAuxiliaryNamesPDR(pdr);
131 if (!sensorAuxNames)
132 {
133 lg2::error(
134 "Failed to parse PDR with type {TYPE} handle {HANDLE}",
135 "TYPE", pdrHdr->type, "HANDLE",
136 static_cast<uint32_t>(pdrHdr->record_handle));
137 continue;
138 }
139 sensorAuxiliaryNamesTbl.emplace_back(std::move(sensorAuxNames));
140 break;
141 }
142 case PLDM_NUMERIC_SENSOR_PDR:
143 {
144 auto parsedPdr = parseNumericSensorPDR(pdr);
145 if (!parsedPdr)
146 {
147 lg2::error(
148 "Failed to parse PDR with type {TYPE} handle {HANDLE}",
149 "TYPE", pdrHdr->type, "HANDLE",
150 static_cast<uint32_t>(pdrHdr->record_handle));
151 continue;
152 }
153 numericSensorPdrs.emplace_back(std::move(parsedPdr));
154 break;
155 }
156 case PLDM_COMPACT_NUMERIC_SENSOR_PDR:
157 {
158 auto parsedPdr = parseCompactNumericSensorPDR(pdr);
159 if (!parsedPdr)
160 {
161 lg2::error(
162 "Failed to parse PDR with type {TYPE} handle {HANDLE}",
163 "TYPE", pdrHdr->type, "HANDLE",
164 static_cast<uint32_t>(pdrHdr->record_handle));
165 continue;
166 }
167 auto sensorAuxNames = parseCompactNumericSensorNames(pdr);
168 if (!sensorAuxNames)
169 {
170 lg2::error(
171 "Failed to parse sensor name PDR with type {TYPE} handle {HANDLE}",
172 "TYPE", pdrHdr->type, "HANDLE",
173 static_cast<uint32_t>(pdrHdr->record_handle));
174 continue;
175 }
176 compactNumericSensorPdrs.emplace_back(std::move(parsedPdr));
177 sensorAuxiliaryNamesTbl.emplace_back(std::move(sensorAuxNames));
178 break;
179 }
180 case PLDM_ENTITY_AUXILIARY_NAMES_PDR:
181 {
182 auto entityNames = parseEntityAuxiliaryNamesPDR(pdr);
183 if (!entityNames)
184 {
185 lg2::error(
186 "Failed to parse sensor name PDR with type {TYPE} handle {HANDLE}",
187 "TYPE", pdrHdr->type, "HANDLE",
188 static_cast<uint32_t>(pdrHdr->record_handle));
189 continue;
190 }
191 entityAuxiliaryNamesTbl.emplace_back(std::move(entityNames));
192 break;
193 }
194 default:
195 {
196 lg2::error("Unsupported PDR with type {TYPE} handle {HANDLE}",
197 "TYPE", pdrHdr->type, "HANDLE",
198 static_cast<uint32_t>(pdrHdr->record_handle));
199 break;
200 }
201 }
202 }
203
204 auto tName = findTerminusName();
205 if (tName && !tName.value().empty())
206 {
207 lg2::info("Terminus {TID} has Auxiliary Name {NAME}.", "TID", tid,
208 "NAME", tName.value());
209 terminusName = static_cast<std::string>(tName.value());
210 }
211
212 if (terminusName.empty())
213 {
214 terminusName = std::format("Terminus_{}", tid);
215 }
216
217 if (createInventoryPath(terminusName))
218 {
219 lg2::info("Terminus ID {TID}: Created Inventory path {PATH}.", "TID",
220 tid, "PATH", inventoryPath);
221 }
222
223 addNextSensorFromPDRs();
224 }
225
addNextSensorFromPDRs()226 void Terminus::addNextSensorFromPDRs()
227 {
228 sensorCreationEvent.reset();
229
230 if (terminusName.empty())
231 {
232 lg2::error(
233 "Terminus ID {TID}: DOES NOT have name. Skip Adding sensors.",
234 "TID", tid);
235 return;
236 }
237
238 auto pdrIt = sensorPdrIt;
239
240 if (pdrIt < numericSensorPdrs.size())
241 {
242 const auto& pdr = numericSensorPdrs[pdrIt];
243 // Defer adding the next Numeric Sensor
244 sensorCreationEvent = std::make_unique<sdeventplus::source::Defer>(
245 event,
246 std::bind(std::mem_fn(&Terminus::addNumericSensor), this, pdr));
247 }
248 else if (pdrIt < numericSensorPdrs.size() + compactNumericSensorPdrs.size())
249 {
250 pdrIt -= numericSensorPdrs.size();
251 const auto& pdr = compactNumericSensorPdrs[pdrIt];
252 // Defer adding the next Compact Numeric Sensor
253 sensorCreationEvent = std::make_unique<sdeventplus::source::Defer>(
254 event, std::bind(std::mem_fn(&Terminus::addCompactNumericSensor),
255 this, pdr));
256 }
257 else
258 {
259 sensorPdrIt = 0;
260 return;
261 }
262
263 // Move the iteration to the next sensor PDR
264 sensorPdrIt++;
265 }
266
getSensorAuxiliaryNames(SensorID id)267 std::shared_ptr<SensorAuxiliaryNames> Terminus::getSensorAuxiliaryNames(
268 SensorID id)
269 {
270 auto it = std::find_if(
271 sensorAuxiliaryNamesTbl.begin(), sensorAuxiliaryNamesTbl.end(),
272 [id](
273 const std::shared_ptr<SensorAuxiliaryNames>& sensorAuxiliaryNames) {
274 const auto& [sensorId, sensorCnt, sensorNames] =
275 *sensorAuxiliaryNames;
276 return sensorId == id;
277 });
278
279 if (it != sensorAuxiliaryNamesTbl.end())
280 {
281 return *it;
282 }
283 return nullptr;
284 };
285
parseSensorAuxiliaryNamesPDR(const std::vector<uint8_t> & pdrData)286 std::shared_ptr<SensorAuxiliaryNames> Terminus::parseSensorAuxiliaryNamesPDR(
287 const std::vector<uint8_t>& pdrData)
288 {
289 constexpr uint8_t nullTerminator = 0;
290 auto pdr = reinterpret_cast<const struct pldm_sensor_auxiliary_names_pdr*>(
291 pdrData.data());
292 const uint8_t* ptr = pdr->names;
293 std::vector<AuxiliaryNames> sensorAuxNames{};
294 char16_t alignedBuffer[PLDM_STR_UTF_16_MAX_LEN];
295 for ([[maybe_unused]] const auto& sensor :
296 std::views::iota(0, static_cast<int>(pdr->sensor_count)))
297 {
298 const uint8_t nameStringCount = static_cast<uint8_t>(*ptr);
299 ptr += sizeof(uint8_t);
300 AuxiliaryNames nameStrings{};
301 for ([[maybe_unused]] const auto& count :
302 std::views::iota(0, static_cast<int>(nameStringCount)))
303 {
304 std::string_view nameLanguageTag(
305 reinterpret_cast<const char*>(ptr));
306 ptr += nameLanguageTag.size() + sizeof(nullTerminator);
307
308 int u16NameStringLen = 0;
309 for (int i = 0; ptr[i] != 0 || ptr[i + 1] != 0; i += 2)
310 {
311 u16NameStringLen++;
312 }
313 /* include terminator */
314 u16NameStringLen++;
315
316 std::fill(std::begin(alignedBuffer), std::end(alignedBuffer), 0);
317 if (u16NameStringLen > PLDM_STR_UTF_16_MAX_LEN)
318 {
319 lg2::error("Sensor name too long.");
320 return nullptr;
321 }
322 memcpy(alignedBuffer, ptr, u16NameStringLen * sizeof(uint16_t));
323 std::u16string u16NameString(alignedBuffer, u16NameStringLen);
324 ptr += u16NameString.size() * sizeof(uint16_t);
325 std::transform(u16NameString.cbegin(), u16NameString.cend(),
326 u16NameString.begin(),
327 [](uint16_t utf16) { return be16toh(utf16); });
328 #pragma GCC diagnostic push
329 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
330 std::string nameString =
331 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,
332 char16_t>{}
333 .to_bytes(u16NameString);
334 #pragma GCC diagnostic pop
335 nameStrings.emplace_back(std::make_pair(
336 nameLanguageTag, pldm::utils::trimNameForDbus(nameString)));
337 }
338 sensorAuxNames.emplace_back(std::move(nameStrings));
339 }
340 return std::make_shared<SensorAuxiliaryNames>(
341 pdr->sensor_id, pdr->sensor_count, std::move(sensorAuxNames));
342 }
343
parseEntityAuxiliaryNamesPDR(const std::vector<uint8_t> & pdrData)344 std::shared_ptr<EntityAuxiliaryNames> Terminus::parseEntityAuxiliaryNamesPDR(
345 const std::vector<uint8_t>& pdrData)
346 {
347 auto names_offset = sizeof(struct pldm_pdr_hdr) +
348 PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH;
349 auto names_size = pdrData.size() - names_offset;
350
351 size_t decodedPdrSize =
352 sizeof(struct pldm_entity_auxiliary_names_pdr) + names_size;
353 auto vPdr = std::vector<char>(decodedPdrSize);
354 auto decodedPdr = new (vPdr.data()) pldm_entity_auxiliary_names_pdr;
355
356 auto rc = decode_entity_auxiliary_names_pdr(pdrData.data(), pdrData.size(),
357 decodedPdr, decodedPdrSize);
358
359 if (rc)
360 {
361 lg2::error(
362 "Failed to decode Entity Auxiliary Name PDR data, error {RC}.",
363 "RC", rc);
364 return nullptr;
365 }
366
367 auto vNames =
368 std::vector<pldm_entity_auxiliary_name>(decodedPdr->name_string_count);
369 decodedPdr->names = vNames.data();
370
371 rc = decode_pldm_entity_auxiliary_names_pdr_index(decodedPdr);
372 if (rc)
373 {
374 lg2::error("Failed to decode Entity Auxiliary Name, error {RC}.", "RC",
375 rc);
376 return nullptr;
377 }
378
379 AuxiliaryNames nameStrings{};
380 for (const auto& count :
381 std::views::iota(0, static_cast<int>(decodedPdr->name_string_count)))
382 {
383 std::string_view nameLanguageTag =
384 static_cast<std::string_view>(decodedPdr->names[count].tag);
385 const size_t u16NameStringLen =
386 std::char_traits<char16_t>::length(decodedPdr->names[count].name);
387 std::u16string u16NameString(decodedPdr->names[count].name,
388 u16NameStringLen);
389 std::transform(u16NameString.cbegin(), u16NameString.cend(),
390 u16NameString.begin(),
391 [](uint16_t utf16) { return be16toh(utf16); });
392 #pragma GCC diagnostic push
393 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
394 std::string nameString =
395 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}
396 .to_bytes(u16NameString);
397 #pragma GCC diagnostic pop
398 nameStrings.emplace_back(std::make_pair(
399 nameLanguageTag, pldm::utils::trimNameForDbus(nameString)));
400 }
401
402 EntityKey key{decodedPdr->container.entity_type,
403 decodedPdr->container.entity_instance_num,
404 decodedPdr->container.entity_container_id};
405
406 return std::make_shared<EntityAuxiliaryNames>(key, nameStrings);
407 }
408
parseNumericSensorPDR(const std::vector<uint8_t> & pdr)409 std::shared_ptr<pldm_numeric_sensor_value_pdr> Terminus::parseNumericSensorPDR(
410 const std::vector<uint8_t>& pdr)
411 {
412 const uint8_t* ptr = pdr.data();
413 auto parsedPdr = std::make_shared<pldm_numeric_sensor_value_pdr>();
414 auto rc = decode_numeric_sensor_pdr_data(ptr, pdr.size(), parsedPdr.get());
415 if (rc)
416 {
417 return nullptr;
418 }
419 return parsedPdr;
420 }
421
addNumericSensor(const std::shared_ptr<pldm_numeric_sensor_value_pdr> pdr)422 void Terminus::addNumericSensor(
423 const std::shared_ptr<pldm_numeric_sensor_value_pdr> pdr)
424 {
425 if (!pdr)
426 {
427 lg2::error(
428 "Terminus ID {TID}: Skip adding Numeric Sensor - invalid pointer to PDR.",
429 "TID", tid);
430 addNextSensorFromPDRs();
431 }
432
433 auto sensorId = pdr->sensor_id;
434 auto sensorNames = getSensorNames(sensorId);
435
436 if (sensorNames.empty())
437 {
438 lg2::error(
439 "Terminus ID {TID}: Failed to get name for Numeric Sensor {SID}",
440 "TID", tid, "SID", sensorId);
441 addNextSensorFromPDRs();
442 }
443
444 std::string sensorName = sensorNames.front();
445
446 try
447 {
448 auto sensor = std::make_shared<NumericSensor>(
449 tid, true, pdr, sensorName, inventoryPath);
450 lg2::info("Created NumericSensor {NAME}", "NAME", sensorName);
451 numericSensors.emplace_back(sensor);
452 }
453 catch (const sdbusplus::exception_t& e)
454 {
455 lg2::error(
456 "Failed to create NumericSensor. error - {ERROR} sensorname - {NAME}",
457 "ERROR", e, "NAME", sensorName);
458 }
459
460 addNextSensorFromPDRs();
461 }
462
parseCompactNumericSensorNames(const std::vector<uint8_t> & sPdr)463 std::shared_ptr<SensorAuxiliaryNames> Terminus::parseCompactNumericSensorNames(
464 const std::vector<uint8_t>& sPdr)
465 {
466 std::vector<std::vector<std::pair<NameLanguageTag, SensorName>>>
467 sensorAuxNames{};
468 AuxiliaryNames nameStrings{};
469
470 auto pdr =
471 reinterpret_cast<const pldm_compact_numeric_sensor_pdr*>(sPdr.data());
472
473 if (sPdr.size() <
474 (sizeof(pldm_compact_numeric_sensor_pdr) - sizeof(uint8_t)))
475 {
476 return nullptr;
477 }
478
479 if (!pdr->sensor_name_length ||
480 (sPdr.size() < (sizeof(pldm_compact_numeric_sensor_pdr) -
481 sizeof(uint8_t) + pdr->sensor_name_length)))
482 {
483 return nullptr;
484 }
485
486 std::string nameString(reinterpret_cast<const char*>(pdr->sensor_name),
487 pdr->sensor_name_length);
488 nameStrings.emplace_back(
489 std::make_pair("en", pldm::utils::trimNameForDbus(nameString)));
490 sensorAuxNames.emplace_back(std::move(nameStrings));
491
492 return std::make_shared<SensorAuxiliaryNames>(pdr->sensor_id, 1,
493 std::move(sensorAuxNames));
494 }
495
496 std::shared_ptr<pldm_compact_numeric_sensor_pdr>
parseCompactNumericSensorPDR(const std::vector<uint8_t> & sPdr)497 Terminus::parseCompactNumericSensorPDR(const std::vector<uint8_t>& sPdr)
498 {
499 auto pdr =
500 reinterpret_cast<const pldm_compact_numeric_sensor_pdr*>(sPdr.data());
501 if (sPdr.size() < sizeof(pldm_compact_numeric_sensor_pdr))
502 {
503 // Handle error: input data too small to contain valid pdr
504 return nullptr;
505 }
506 auto parsedPdr = std::make_shared<pldm_compact_numeric_sensor_pdr>();
507
508 parsedPdr->hdr = pdr->hdr;
509 parsedPdr->terminus_handle = pdr->terminus_handle;
510 parsedPdr->sensor_id = pdr->sensor_id;
511 parsedPdr->entity_type = pdr->entity_type;
512 parsedPdr->entity_instance = pdr->entity_instance;
513 parsedPdr->container_id = pdr->container_id;
514 parsedPdr->sensor_name_length = pdr->sensor_name_length;
515 parsedPdr->base_unit = pdr->base_unit;
516 parsedPdr->unit_modifier = pdr->unit_modifier;
517 parsedPdr->occurrence_rate = pdr->occurrence_rate;
518 parsedPdr->range_field_support = pdr->range_field_support;
519 parsedPdr->warning_high = pdr->warning_high;
520 parsedPdr->warning_low = pdr->warning_low;
521 parsedPdr->critical_high = pdr->critical_high;
522 parsedPdr->critical_low = pdr->critical_low;
523 parsedPdr->fatal_high = pdr->fatal_high;
524 parsedPdr->fatal_low = pdr->fatal_low;
525 return parsedPdr;
526 }
527
addCompactNumericSensor(const std::shared_ptr<pldm_compact_numeric_sensor_pdr> pdr)528 void Terminus::addCompactNumericSensor(
529 const std::shared_ptr<pldm_compact_numeric_sensor_pdr> pdr)
530 {
531 if (!pdr)
532 {
533 lg2::error(
534 "Terminus ID {TID}: Skip adding Compact Numeric Sensor - invalid pointer to PDR.",
535 "TID", tid);
536 addNextSensorFromPDRs();
537 }
538
539 auto sensorId = pdr->sensor_id;
540 auto sensorNames = getSensorNames(sensorId);
541
542 if (sensorNames.empty())
543 {
544 lg2::error(
545 "Terminus ID {TID}: Failed to get name for Compact Numeric Sensor {SID}",
546 "TID", tid, "SID", sensorId);
547 addNextSensorFromPDRs();
548 }
549
550 std::string sensorName = sensorNames.front();
551
552 try
553 {
554 auto sensor = std::make_shared<NumericSensor>(
555 tid, true, pdr, sensorName, inventoryPath);
556 lg2::info("Created Compact NumericSensor {NAME}", "NAME", sensorName);
557 numericSensors.emplace_back(sensor);
558 }
559 catch (const sdbusplus::exception_t& e)
560 {
561 lg2::error(
562 "Failed to create Compact NumericSensor. error - {ERROR} sensorname - {NAME}",
563 "ERROR", e, "NAME", sensorName);
564 }
565
566 addNextSensorFromPDRs();
567 }
568
getSensorObject(SensorID id)569 std::shared_ptr<NumericSensor> Terminus::getSensorObject(SensorID id)
570 {
571 if (terminusName.empty())
572 {
573 lg2::error(
574 "Terminus ID {TID}: DOES NOT have terminus name. No numeric sensor object.",
575 "TID", tid);
576 return nullptr;
577 }
578 if (!numericSensors.size())
579 {
580 lg2::error("Terminus ID {TID} name {NAME}: DOES NOT have sensor.",
581 "TID", tid, "NAME", terminusName);
582 return nullptr;
583 }
584
585 for (auto& sensor : numericSensors)
586 {
587 if (!sensor)
588 {
589 continue;
590 }
591
592 if (sensor->sensorId == id)
593 {
594 return sensor;
595 }
596 }
597
598 return nullptr;
599 }
600
601 /** @brief Check if a pointer is go through end of table
602 * @param[in] table - pointer to FRU record table
603 * @param[in] p - pointer to each record of FRU record table
604 * @param[in] tableSize - FRU table size
605 */
isTableEnd(const uint8_t * table,const uint8_t * p,const size_t tableSize)606 static bool isTableEnd(const uint8_t* table, const uint8_t* p,
607 const size_t tableSize)
608 {
609 auto offset = p - table;
610 return (tableSize - offset) < sizeof(struct pldm_fru_record_data_format);
611 }
612
updateInventoryWithFru(const uint8_t * fruData,const size_t fruLen)613 void Terminus::updateInventoryWithFru(const uint8_t* fruData,
614 const size_t fruLen)
615 {
616 auto tmp = getTerminusName();
617 if (!tmp || tmp.value().empty())
618 {
619 lg2::error(
620 "Terminus ID {TID}: Failed to update Inventory with Fru Data - error : Terminus name is empty.",
621 "TID", tid);
622 return;
623 }
624
625 if (createInventoryPath(static_cast<std::string>(tmp.value())))
626 {
627 lg2::info("Terminus ID {TID}: Created Inventory path.", "TID", tid);
628 }
629
630 auto ptr = fruData;
631 while (!isTableEnd(fruData, ptr, fruLen))
632 {
633 auto record = reinterpret_cast<const pldm_fru_record_data_format*>(ptr);
634 ptr += sizeof(pldm_fru_record_data_format) -
635 sizeof(pldm_fru_record_tlv);
636
637 if (!record->num_fru_fields)
638 {
639 lg2::error(
640 "Invalid number of fields {NUM} of Record ID Type {TYPE} of terminus {TID}",
641 "NUM", record->num_fru_fields, "TYPE", record->record_type,
642 "TID", tid);
643 return;
644 }
645
646 if (record->record_type != PLDM_FRU_RECORD_TYPE_GENERAL)
647 {
648 lg2::error(
649 "Does not support Fru Record ID Type {TYPE} of terminus {TID}",
650 "TYPE", record->record_type, "TID", tid);
651
652 for ([[maybe_unused]] const auto& idx :
653 std::views::iota(0, static_cast<int>(record->num_fru_fields)))
654 {
655 auto tlv = reinterpret_cast<const pldm_fru_record_tlv*>(ptr);
656 ptr += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
657 }
658 continue;
659 }
660 /* FRU General record type */
661 for ([[maybe_unused]] const auto& idx :
662 std::views::iota(0, static_cast<int>(record->num_fru_fields)))
663 {
664 auto tlv = reinterpret_cast<const pldm_fru_record_tlv*>(ptr);
665 std::string fruField{};
666 if (tlv->type != PLDM_FRU_FIELD_TYPE_IANA)
667 {
668 auto strOptional =
669 pldm::utils::fruFieldValuestring(tlv->value, tlv->length);
670 if (!strOptional)
671 {
672 ptr += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
673 continue;
674 }
675 fruField = strOptional.value();
676
677 if (fruField.empty())
678 {
679 ptr += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
680 continue;
681 }
682 }
683
684 switch (tlv->type)
685 {
686 case PLDM_FRU_FIELD_TYPE_MODEL:
687 inventoryItemBoardInft->model(fruField);
688 break;
689 case PLDM_FRU_FIELD_TYPE_PN:
690 inventoryItemBoardInft->partNumber(fruField);
691 break;
692 case PLDM_FRU_FIELD_TYPE_SN:
693 inventoryItemBoardInft->serialNumber(fruField);
694 break;
695 case PLDM_FRU_FIELD_TYPE_MANUFAC:
696 inventoryItemBoardInft->manufacturer(fruField);
697 break;
698 case PLDM_FRU_FIELD_TYPE_NAME:
699 inventoryItemBoardInft->names({fruField});
700 break;
701 case PLDM_FRU_FIELD_TYPE_VERSION:
702 inventoryItemBoardInft->version(fruField);
703 break;
704 case PLDM_FRU_FIELD_TYPE_ASSET_TAG:
705 inventoryItemBoardInft->assetTag(fruField);
706 break;
707 case PLDM_FRU_FIELD_TYPE_VENDOR:
708 case PLDM_FRU_FIELD_TYPE_CHASSIS:
709 case PLDM_FRU_FIELD_TYPE_SKU:
710 case PLDM_FRU_FIELD_TYPE_DESC:
711 case PLDM_FRU_FIELD_TYPE_EC_LVL:
712 case PLDM_FRU_FIELD_TYPE_OTHER:
713 break;
714 case PLDM_FRU_FIELD_TYPE_IANA:
715 auto iana =
716 pldm::utils::fruFieldParserU32(tlv->value, tlv->length);
717 if (!iana)
718 {
719 ptr += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
720 continue;
721 }
722 break;
723 }
724 ptr += sizeof(pldm_fru_record_tlv) - 1 + tlv->length;
725 }
726 }
727 }
728
getSensorNames(const SensorID & sensorId)729 std::vector<std::string> Terminus::getSensorNames(const SensorID& sensorId)
730 {
731 std::vector<std::string> sensorNames;
732 std::string defaultName =
733 std::format("{}_Sensor_{}", terminusName, unsigned(sensorId));
734 // To ensure there's always a default name at offset 0
735 sensorNames.emplace_back(defaultName);
736
737 auto sensorAuxiliaryNames = getSensorAuxiliaryNames(sensorId);
738 if (!sensorAuxiliaryNames)
739 {
740 return sensorNames;
741 }
742
743 const auto& [id, sensorCount, nameMap] = *sensorAuxiliaryNames;
744 for (const unsigned int& i :
745 std::views::iota(0, static_cast<int>(sensorCount)))
746 {
747 auto sensorName = defaultName;
748 if (i > 0)
749 {
750 // Sensor name at offset 0 will be the default name
751 sensorName += "_" + std::to_string(i);
752 }
753
754 for (const auto& [languageTag, name] : nameMap[i])
755 {
756 if (languageTag == "en" && !name.empty())
757 {
758 sensorName = std::format("{}_{}", terminusName, name);
759 }
760 }
761
762 if (i >= sensorNames.size())
763 {
764 sensorNames.emplace_back(sensorName);
765 }
766 else
767 {
768 sensorNames[i] = sensorName;
769 }
770 }
771
772 return sensorNames;
773 }
774
775 } // namespace platform_mc
776 } // namespace pldm
777