blob: f09150091718a128c845daee04f309648779e02a [file] [log] [blame]
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301#include "config.h"
2
Sunny Srivastava6c71c9d2021-04-15 04:43:54 -05003#include "common_utility.hpp"
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05304#include "defines.hpp"
Sunny Srivastava6c71c9d2021-04-15 04:43:54 -05005#include "ibm_vpd_utils.hpp"
SunnySrivastava1984e12b1812020-05-26 02:23:11 -05006#include "ipz_parser.hpp"
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05307#include "keyword_vpd_parser.hpp"
Alpana Kumaria00936f2020-04-14 07:15:46 -05008#include "memory_vpd_parser.hpp"
SunnySrivastava1984e12b1812020-05-26 02:23:11 -05009#include "parser_factory.hpp"
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -050010#include "vpd_exceptions.hpp"
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053011
SunnySrivastava19849094d4f2020-08-05 09:32:29 -050012#include <assert.h>
Alpana Kumari8ea3f6d2020-04-02 00:26:07 -050013#include <ctype.h>
14
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053015#include <CLI/CLI.hpp>
Santosh Puranik88edeb62020-03-02 12:00:09 +053016#include <algorithm>
Alpana Kumari65b83602020-09-01 00:24:56 -050017#include <cstdarg>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053018#include <exception>
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +053019#include <filesystem>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053020#include <fstream>
Alpana Kumari2f793042020-08-18 05:51:03 -050021#include <gpiod.hpp>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053022#include <iostream>
23#include <iterator>
24#include <nlohmann/json.hpp>
Andrew Geissler280197e2020-12-08 20:51:49 -060025#include <phosphor-logging/log.hpp>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053026
27using namespace std;
28using namespace openpower::vpd;
29using namespace CLI;
30using namespace vpd::keyword::parser;
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +053031using namespace openpower::vpd::constants;
32namespace fs = filesystem;
33using json = nlohmann::json;
SunnySrivastava1984e12b1812020-05-26 02:23:11 -050034using namespace openpower::vpd::parser::factory;
SunnySrivastava1984945a02d2020-05-06 01:55:41 -050035using namespace openpower::vpd::inventory;
Alpana Kumaria00936f2020-04-14 07:15:46 -050036using namespace openpower::vpd::memory::parser;
SunnySrivastava1984e12b1812020-05-26 02:23:11 -050037using namespace openpower::vpd::parser::interface;
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -050038using namespace openpower::vpd::exceptions;
Andrew Geissler280197e2020-12-08 20:51:49 -060039using namespace phosphor::logging;
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053040
Alpana Kumari65b83602020-09-01 00:24:56 -050041static const deviceTreeMap deviceTreeSystemTypeMap = {
Joel Stanley6fb0ef92021-05-26 13:14:32 +093042 {RAINIER_2U, "conf-aspeed-bmc-ibm-rainier-p1.dtb"},
43 {RAINIER_2U_V2, "conf-aspeed-bmc-ibm-rainier.dtb"},
44 {RAINIER_4U, "conf-aspeed-bmc-ibm-rainier-4u-p1.dtb"},
45 {RAINIER_4U_V2, "conf-aspeed-bmc-ibm-rainier-4u.dtb"},
Andrew Geissler2fe709f2021-03-25 10:59:07 -050046 {RAINIER_1S4U, "conf-aspeed-bmc-ibm-rainier-1s4u.dtb"},
47 {EVEREST, "conf-aspeed-bmc-ibm-everest.dtb"}};
Alpana Kumari65b83602020-09-01 00:24:56 -050048
Santosh Puranik88edeb62020-03-02 12:00:09 +053049/**
Santosh Puranik85893752020-11-10 21:31:43 +053050 * @brief Returns the power state for chassis0
51 */
52static auto getPowerState()
53{
54 // TODO: How do we handle multiple chassis?
55 string powerState{};
56 auto bus = sdbusplus::bus::new_default();
57 auto properties =
58 bus.new_method_call("xyz.openbmc_project.State.Chassis",
59 "/xyz/openbmc_project/state/chassis0",
60 "org.freedesktop.DBus.Properties", "Get");
61 properties.append("xyz.openbmc_project.State.Chassis");
62 properties.append("CurrentPowerState");
63 auto result = bus.call(properties);
64 if (!result.is_method_error())
65 {
66 variant<string> val;
67 result.read(val);
68 if (auto pVal = get_if<string>(&val))
69 {
70 powerState = *pVal;
71 }
72 }
73 cout << "Power state is: " << powerState << endl;
74 return powerState;
75}
76
77/**
Santosh Puranik88edeb62020-03-02 12:00:09 +053078 * @brief Expands location codes
79 */
80static auto expandLocationCode(const string& unexpanded, const Parsed& vpdMap,
81 bool isSystemVpd)
82{
83 auto expanded{unexpanded};
84 static constexpr auto SYSTEM_OBJECT = "/system/chassis/motherboard";
85 static constexpr auto VCEN_IF = "com.ibm.ipzvpd.VCEN";
86 static constexpr auto VSYS_IF = "com.ibm.ipzvpd.VSYS";
87 size_t idx = expanded.find("fcs");
88 try
89 {
90 if (idx != string::npos)
91 {
92 string fc{};
93 string se{};
94 if (isSystemVpd)
95 {
96 const auto& fcData = vpdMap.at("VCEN").at("FC");
97 const auto& seData = vpdMap.at("VCEN").at("SE");
98 fc = string(fcData.data(), fcData.size());
99 se = string(seData.data(), seData.size());
100 }
101 else
102 {
103 fc = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "FC");
104 se = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "SE");
105 }
106
Alpana Kumari81671f62021-02-10 02:21:59 -0600107 // TODO: See if ND0 can be placed in the JSON
108 expanded.replace(idx, 3, fc.substr(0, 4) + ".ND0." + se);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530109 }
110 else
111 {
112 idx = expanded.find("mts");
113 if (idx != string::npos)
114 {
115 string mt{};
116 string se{};
117 if (isSystemVpd)
118 {
119 const auto& mtData = vpdMap.at("VSYS").at("TM");
120 const auto& seData = vpdMap.at("VSYS").at("SE");
121 mt = string(mtData.data(), mtData.size());
122 se = string(seData.data(), seData.size());
123 }
124 else
125 {
126 mt = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "TM");
127 se = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "SE");
128 }
129
130 replace(mt.begin(), mt.end(), '-', '.');
131 expanded.replace(idx, 3, mt + "." + se);
132 }
133 }
134 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500135 catch (exception& e)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530136 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500137 cerr << "Failed to expand location code with exception: " << e.what()
138 << "\n";
Santosh Puranik88edeb62020-03-02 12:00:09 +0530139 }
140 return expanded;
141}
Alpana Kumari2f793042020-08-18 05:51:03 -0500142
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530143/**
144 * @brief Populate FRU specific interfaces.
145 *
146 * This is a common method which handles both
147 * ipz and keyword specific interfaces thus,
148 * reducing the code redundancy.
149 * @param[in] map - Reference to the innermost keyword-value map.
150 * @param[in] preIntrStr - Reference to the interface string.
151 * @param[out] interfaces - Reference to interface map.
152 */
153template <typename T>
154static void populateFruSpecificInterfaces(const T& map,
155 const string& preIntrStr,
156 inventory::InterfaceMap& interfaces)
157{
158 inventory::PropertyMap prop;
159
160 for (const auto& kwVal : map)
161 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500162 vector<uint8_t> vec(kwVal.second.begin(), kwVal.second.end());
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530163
164 auto kw = kwVal.first;
165
166 if (kw[0] == '#')
167 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500168 kw = string("PD_") + kw[1];
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530169 }
Alpana Kumari8ea3f6d2020-04-02 00:26:07 -0500170 else if (isdigit(kw[0]))
171 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500172 kw = string("N_") + kw;
Alpana Kumari8ea3f6d2020-04-02 00:26:07 -0500173 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530174 prop.emplace(move(kw), move(vec));
175 }
176
177 interfaces.emplace(preIntrStr, move(prop));
178}
179
180/**
181 * @brief Populate Interfaces.
182 *
183 * This method populates common and extra interfaces to dbus.
184 * @param[in] js - json object
185 * @param[out] interfaces - Reference to interface map
186 * @param[in] vpdMap - Reference to the parsed vpd map.
Santosh Puranik88edeb62020-03-02 12:00:09 +0530187 * @param[in] isSystemVpd - Denotes whether we are collecting the system VPD.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530188 */
189template <typename T>
190static void populateInterfaces(const nlohmann::json& js,
191 inventory::InterfaceMap& interfaces,
Santosh Puranik88edeb62020-03-02 12:00:09 +0530192 const T& vpdMap, bool isSystemVpd)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530193{
194 for (const auto& ifs : js.items())
195 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530196 string inf = ifs.key();
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530197 inventory::PropertyMap props;
198
199 for (const auto& itr : ifs.value().items())
200 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530201 const string& busProp = itr.key();
202
Alpana Kumari31970de2020-02-17 06:49:57 -0600203 if (itr.value().is_boolean())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530204 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530205 props.emplace(busProp, itr.value().get<bool>());
206 }
207 else if (itr.value().is_string())
208 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500209 if constexpr (is_same<T, Parsed>::value)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530210 {
211 if (busProp == "LocationCode" &&
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000212 inf == IBM_LOCATION_CODE_INF)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530213 {
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000214 // TODO deprecate the com.ibm interface later
Santosh Puranik88edeb62020-03-02 12:00:09 +0530215 auto prop = expandLocationCode(
216 itr.value().get<string>(), vpdMap, isSystemVpd);
217 props.emplace(busProp, prop);
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000218 interfaces.emplace(XYZ_LOCATION_CODE_INF, props);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530219 }
220 else
221 {
222 props.emplace(busProp, itr.value().get<string>());
223 }
224 }
225 else
226 {
227 props.emplace(busProp, itr.value().get<string>());
228 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530229 }
Alpana Kumari31970de2020-02-17 06:49:57 -0600230 else if (itr.value().is_object())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530231 {
Alpana Kumari31970de2020-02-17 06:49:57 -0600232 const string& rec = itr.value().value("recordName", "");
233 const string& kw = itr.value().value("keywordName", "");
234 const string& encoding = itr.value().value("encoding", "");
235
Alpana Kumari58e22142020-05-05 00:22:12 -0500236 if constexpr (is_same<T, Parsed>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530237 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530238 if (!rec.empty() && !kw.empty() && vpdMap.count(rec) &&
239 vpdMap.at(rec).count(kw))
Alpana Kumari31970de2020-02-17 06:49:57 -0600240 {
241 auto encoded =
242 encodeKeyword(vpdMap.at(rec).at(kw), encoding);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530243 props.emplace(busProp, encoded);
Alpana Kumari31970de2020-02-17 06:49:57 -0600244 }
245 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500246 else if constexpr (is_same<T, KeywordVpdMap>::value)
Alpana Kumari31970de2020-02-17 06:49:57 -0600247 {
248 if (!kw.empty() && vpdMap.count(kw))
249 {
250 auto prop =
251 string(vpdMap.at(kw).begin(), vpdMap.at(kw).end());
252 auto encoded = encodeKeyword(prop, encoding);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530253 props.emplace(busProp, encoded);
Alpana Kumari31970de2020-02-17 06:49:57 -0600254 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530255 }
256 }
257 }
258 interfaces.emplace(inf, move(props));
259 }
260}
261
Alpana Kumari2f793042020-08-18 05:51:03 -0500262static Binary getVpdDataInVector(const nlohmann::json& js, const string& file)
Alpana Kumari58e22142020-05-05 00:22:12 -0500263{
264 uint32_t offset = 0;
265 // check if offset present?
266 for (const auto& item : js["frus"][file])
267 {
268 if (item.find("offset") != item.end())
269 {
270 offset = item["offset"];
271 }
272 }
273
274 // TODO: Figure out a better way to get max possible VPD size.
275 Binary vpdVector;
276 vpdVector.resize(65504);
277 ifstream vpdFile;
278 vpdFile.open(file, ios::binary);
279
280 vpdFile.seekg(offset, ios_base::cur);
281 vpdFile.read(reinterpret_cast<char*>(&vpdVector[0]), 65504);
282 vpdVector.resize(vpdFile.gcount());
283
284 return vpdVector;
285}
286
Alpana Kumari2f793042020-08-18 05:51:03 -0500287/** This API will be called at the end of VPD collection to perform any post
288 * actions.
289 *
290 * @param[in] json - json object
291 * @param[in] file - eeprom file path
292 */
293static void postFailAction(const nlohmann::json& json, const string& file)
294{
295 if ((json["frus"][file].at(0)).find("postActionFail") ==
296 json["frus"][file].at(0).end())
297 {
298 return;
299 }
300
301 uint8_t pinValue = 0;
302 string pinName;
303
304 for (const auto& postAction :
305 (json["frus"][file].at(0))["postActionFail"].items())
306 {
307 if (postAction.key() == "pin")
308 {
309 pinName = postAction.value();
310 }
311 else if (postAction.key() == "value")
312 {
313 // Get the value to set
314 pinValue = postAction.value();
315 }
316 }
317
318 cout << "Setting GPIO: " << pinName << " to " << (int)pinValue << endl;
319
320 try
321 {
322 gpiod::line outputLine = gpiod::find_line(pinName);
323
324 if (!outputLine)
325 {
326 cout << "Couldn't find output line:" << pinName
327 << " on GPIO. Skipping...\n";
328
329 return;
330 }
331 outputLine.request(
332 {"Disable line", ::gpiod::line_request::DIRECTION_OUTPUT, 0},
333 pinValue);
334 }
335 catch (system_error&)
336 {
337 cerr << "Failed to set post-action GPIO" << endl;
338 }
339}
340
341/** Performs any pre-action needed to get the FRU setup for collection.
342 *
343 * @param[in] json - json object
344 * @param[in] file - eeprom file path
345 */
346static void preAction(const nlohmann::json& json, const string& file)
347{
348 if ((json["frus"][file].at(0)).find("preAction") ==
349 json["frus"][file].at(0).end())
350 {
351 return;
352 }
353
354 uint8_t pinValue = 0;
355 string pinName;
356
357 for (const auto& postAction :
358 (json["frus"][file].at(0))["preAction"].items())
359 {
360 if (postAction.key() == "pin")
361 {
362 pinName = postAction.value();
363 }
364 else if (postAction.key() == "value")
365 {
366 // Get the value to set
367 pinValue = postAction.value();
368 }
369 }
370
371 cout << "Setting GPIO: " << pinName << " to " << (int)pinValue << endl;
372 try
373 {
374 gpiod::line outputLine = gpiod::find_line(pinName);
375
376 if (!outputLine)
377 {
378 cout << "Couldn't find output line:" << pinName
379 << " on GPIO. Skipping...\n";
380
381 return;
382 }
383 outputLine.request(
384 {"FRU pre-action", ::gpiod::line_request::DIRECTION_OUTPUT, 0},
385 pinValue);
386 }
387 catch (system_error&)
388 {
389 cerr << "Failed to set pre-action GPIO" << endl;
390 return;
391 }
392
393 // Now bind the device
394 string bind = json["frus"][file].at(0).value("bind", "");
395 cout << "Binding device " << bind << endl;
396 string bindCmd = string("echo \"") + bind +
397 string("\" > /sys/bus/i2c/drivers/at24/bind");
398 cout << bindCmd << endl;
399 executeCmd(bindCmd);
400
401 // Check if device showed up (test for file)
402 if (!fs::exists(file))
403 {
404 cout << "EEPROM " << file << " does not exist. Take failure action"
405 << endl;
406 // If not, then take failure postAction
407 postFailAction(json, file);
408 }
409}
410
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530411/**
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530412 * @brief Prime the Inventory
413 * Prime the inventory by populating only the location code,
414 * type interface and the inventory object for the frus
415 * which are not system vpd fru.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530416 *
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530417 * @param[in] jsObject - Reference to vpd inventory json object
418 * @param[in] vpdMap - Reference to the parsed vpd map
419 *
420 * @returns Map of items in extraInterface.
421 */
422template <typename T>
423inventory::ObjectMap primeInventory(const nlohmann::json& jsObject,
424 const T& vpdMap)
425{
426 inventory::ObjectMap objects;
427
428 for (auto& itemFRUS : jsObject["frus"].items())
429 {
Alpana Kumari2f793042020-08-18 05:51:03 -0500430 // Take pre actions
431 preAction(jsObject, itemFRUS.key());
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530432 for (auto& itemEEPROM : itemFRUS.value())
433 {
434 inventory::InterfaceMap interfaces;
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530435 inventory::Object object(itemEEPROM.at("inventoryPath"));
436
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530437 if ((itemFRUS.key() != systemVpdFilePath) &&
438 !itemEEPROM.value("noprime", false))
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530439 {
Alpana Kumaricfd7a752021-02-07 23:23:01 -0600440 inventory::PropertyMap presProp;
441 presProp.emplace("Present", false);
442 interfaces.emplace("xyz.openbmc_project.Inventory.Item",
443 move(presProp));
444
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530445 if (itemEEPROM.find("extraInterfaces") != itemEEPROM.end())
446 {
447 for (const auto& eI : itemEEPROM["extraInterfaces"].items())
448 {
449 inventory::PropertyMap props;
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000450 if (eI.key() == IBM_LOCATION_CODE_INF)
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530451 {
452 if constexpr (std::is_same<T, Parsed>::value)
453 {
454 for (auto& lC : eI.value().items())
455 {
456 auto propVal = expandLocationCode(
457 lC.value().get<string>(), vpdMap, true);
458
459 props.emplace(move(lC.key()),
460 move(propVal));
Santosh Puranikb0f37492021-06-21 09:42:47 +0530461 interfaces.emplace(XYZ_LOCATION_CODE_INF,
462 props);
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530463 interfaces.emplace(move(eI.key()),
464 move(props));
465 }
466 }
467 }
468 else if (eI.key().find("Inventory.Item.") !=
469 string::npos)
470 {
471 interfaces.emplace(move(eI.key()), move(props));
472 }
473 }
474 }
475 objects.emplace(move(object), move(interfaces));
476 }
477 }
478 }
479 return objects;
480}
481
Alpana Kumari65b83602020-09-01 00:24:56 -0500482/**
483 * @brief This API executes command to set environment variable
484 * And then reboot the system
485 * @param[in] key -env key to set new value
486 * @param[in] value -value to set.
487 */
488void setEnvAndReboot(const string& key, const string& value)
489{
490 // set env and reboot and break.
491 executeCmd("/sbin/fw_setenv", key, value);
Andrew Geissler280197e2020-12-08 20:51:49 -0600492 log<level::INFO>("Rebooting BMC to pick up new device tree");
Alpana Kumari65b83602020-09-01 00:24:56 -0500493 // make dbus call to reboot
494 auto bus = sdbusplus::bus::new_default_system();
495 auto method = bus.new_method_call(
496 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
497 "org.freedesktop.systemd1.Manager", "Reboot");
498 bus.call_noreply(method);
499}
500
501/*
502 * @brief This API checks for env var fitconfig.
503 * If not initialised OR updated as per the current system type,
504 * update this env var and reboot the system.
505 *
506 * @param[in] systemType IM kwd in vpd tells about which system type it is.
507 * */
508void setDevTreeEnv(const string& systemType)
509{
510 string newDeviceTree;
511
512 if (deviceTreeSystemTypeMap.find(systemType) !=
513 deviceTreeSystemTypeMap.end())
514 {
515 newDeviceTree = deviceTreeSystemTypeMap.at(systemType);
516 }
517
518 string readVarValue;
519 bool envVarFound = false;
520
521 vector<string> output = executeCmd("/sbin/fw_printenv");
522 for (const auto& entry : output)
523 {
524 size_t pos = entry.find("=");
525 string key = entry.substr(0, pos);
526 if (key != "fitconfig")
527 {
528 continue;
529 }
530
531 envVarFound = true;
532 if (pos + 1 < entry.size())
533 {
534 readVarValue = entry.substr(pos + 1);
535 if (readVarValue.find(newDeviceTree) != string::npos)
536 {
537 // fitconfig is Updated. No action needed
538 break;
539 }
540 }
541 // set env and reboot and break.
542 setEnvAndReboot(key, newDeviceTree);
543 exit(0);
544 }
545
546 // check If env var Not found
547 if (!envVarFound)
548 {
549 setEnvAndReboot("fitconfig", newDeviceTree);
550 }
551}
552
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530553/**
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500554 * @brief API to call VPD manager to write VPD to EEPROM.
555 * @param[in] Object path.
556 * @param[in] record to be updated.
557 * @param[in] keyword to be updated.
558 * @param[in] keyword data to be updated
559 */
560void updateHardware(const string& objectName, const string& recName,
561 const string& kwdName, const Binary& data)
562{
563 try
564 {
565 auto bus = sdbusplus::bus::new_default();
566 auto properties =
567 bus.new_method_call(BUSNAME, OBJPATH, IFACE, "WriteKeyword");
568 properties.append(
569 static_cast<sdbusplus::message::object_path>(objectName));
570 properties.append(recName);
571 properties.append(kwdName);
572 properties.append(data);
573 bus.call(properties);
574 }
575 catch (const sdbusplus::exception::SdBusError& e)
576 {
577 std::string what =
578 "VPDManager WriteKeyword api failed for inventory path " +
579 objectName;
580 what += " record " + recName;
581 what += " keyword " + kwdName;
582 what += " with bus error = " + std::string(e.what());
583
584 // map to hold additional data in case of logging pel
585 PelAdditionalData additionalData{};
586 additionalData.emplace("CALLOUT_INVENTORY_PATH", objectName);
587 additionalData.emplace("DESCRIPTION", what);
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500588 createPEL(additionalData, PelSeverity::WARNING, errIntfForBusFailure);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500589 }
590}
591
592/**
593 * @brief API to check if we need to restore system VPD
594 * This functionality is only applicable for IPZ VPD data.
595 * @param[in] vpdMap - IPZ vpd map
596 * @param[in] objectPath - Object path for the FRU
597 * @return EEPROMs with records and keywords updated at standby
598 */
599std::vector<RestoredEeproms> restoreSystemVPD(Parsed& vpdMap,
600 const string& objectPath)
601{
602 // the list of keywords for VSYS record is as per the S0 system. Should be
603 // updated for another type of systems
604 static std::unordered_map<std::string, std::vector<std::string>> svpdKwdMap{
605 {"VSYS", {"BR", "TM", "SE", "SU", "RB"}},
606 {"VCEN", {"FC", "SE"}},
607 {"LXR0", {"LX"}}};
608
609 // vector to hold all the EEPROMs updated at standby
610 std::vector<RestoredEeproms> updatedEeproms = {};
611
612 for (const auto& systemRecKwdPair : svpdKwdMap)
613 {
614 auto it = vpdMap.find(systemRecKwdPair.first);
615
616 // check if record is found in map we got by parser
617 if (it != vpdMap.end())
618 {
619 const auto& kwdListForRecord = systemRecKwdPair.second;
620 for (const auto& keyword : kwdListForRecord)
621 {
622 DbusPropertyMap& kwdValMap = it->second;
623 auto iterator = kwdValMap.find(keyword);
624
625 if (iterator != kwdValMap.end())
626 {
627 string& kwdValue = iterator->second;
628
629 // check bus data
630 const string& recordName = systemRecKwdPair.first;
631 const string& busValue = readBusProperty(
632 objectPath, ipzVpdInf + recordName, keyword);
633
634 if (busValue.find_first_not_of(' ') != string::npos)
635 {
636 if (kwdValue.find_first_not_of(' ') != string::npos)
637 {
638 // both the data are present, check for mismatch
639 if (busValue != kwdValue)
640 {
641 string errMsg = "VPD data mismatch on cache "
642 "and hardware for record: ";
643 errMsg += (*it).first;
644 errMsg += " and keyword: ";
645 errMsg += keyword;
646
647 // data mismatch
648 PelAdditionalData additionalData;
649 additionalData.emplace("CALLOUT_INVENTORY_PATH",
650 objectPath);
651
652 additionalData.emplace("DESCRIPTION", errMsg);
653
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500654 createPEL(additionalData, PelSeverity::WARNING,
655 errIntfForInvalidVPD);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500656 }
657 }
658 else
659 {
660 // implies hardware data is blank
661 // update the map
662 Binary busData(busValue.begin(), busValue.end());
663
664 updatedEeproms.push_back(std::make_tuple(
665 objectPath, recordName, keyword, busData));
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500666
Sunny Srivastava90a63b92021-05-26 06:30:24 -0500667 // update the map as well, so that cache data is not
668 // updated as blank while populating VPD map on Dbus
669 // in populateDBus Api
670 kwdValue = busValue;
671 }
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500672 }
673 else if (kwdValue.find_first_not_of(' ') == string::npos)
674 {
675 string errMsg = "VPD is blank on both cache and "
676 "hardware for record: ";
677 errMsg += (*it).first;
678 errMsg += " and keyword: ";
679 errMsg += keyword;
680 errMsg += ". SSR need to update hardware VPD.";
681
682 // both the data are blanks, log PEL
683 PelAdditionalData additionalData;
684 additionalData.emplace("CALLOUT_INVENTORY_PATH",
685 objectPath);
686
687 additionalData.emplace("DESCRIPTION", errMsg);
688
689 // log PEL TODO: Block IPL
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500690 createPEL(additionalData, PelSeverity::ERROR,
691 errIntfForBlankSystemVPD);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500692 continue;
693 }
694 }
695 }
696 }
697 }
698
699 return updatedEeproms;
700}
701
702/**
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530703 * @brief Populate Dbus.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530704 * This method invokes all the populateInterface functions
705 * and notifies PIM about dbus object.
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530706 * @param[in] vpdMap - Either IPZ vpd map or Keyword vpd map based on the
707 * input.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530708 * @param[in] js - Inventory json object
709 * @param[in] filePath - Path of the vpd file
710 * @param[in] preIntrStr - Interface string
711 */
712template <typename T>
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500713static void populateDbus(T& vpdMap, nlohmann::json& js, const string& filePath)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530714{
715 inventory::InterfaceMap interfaces;
716 inventory::ObjectMap objects;
717 inventory::PropertyMap prop;
718
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500719 // map to hold all the keywords whose value has been changed at standby
720 vector<RestoredEeproms> updatedEeproms = {};
721
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530722 bool isSystemVpd = (filePath == systemVpdFilePath);
723 if constexpr (is_same<T, Parsed>::value)
724 {
725 if (isSystemVpd)
726 {
727 std::vector<std::string> interfaces = {motherBoardInterface};
728 // call mapper to check for object path creation
729 MapperResponse subTree =
730 getObjectSubtreeForInterfaces(pimPath, 0, interfaces);
731 string mboardPath =
732 js["frus"][filePath].at(0).value("inventoryPath", "");
733
734 // Attempt system VPD restore if we have a motherboard
735 // object in the inventory.
736 if ((subTree.size() != 0) &&
737 (subTree.find(pimPath + mboardPath) != subTree.end()))
738 {
739 updatedEeproms = restoreSystemVPD(vpdMap, mboardPath);
740 }
741 else
742 {
743 log<level::ERR>("No object path found");
744 }
745 }
746 }
747
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530748 for (const auto& item : js["frus"][filePath])
749 {
750 const auto& objectPath = item["inventoryPath"];
751 sdbusplus::message::object_path object(objectPath);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500752
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530753 // Populate the VPD keywords and the common interfaces only if we
754 // are asked to inherit that data from the VPD, else only add the
755 // extraInterfaces.
756 if (item.value("inherit", true))
757 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500758 if constexpr (is_same<T, Parsed>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530759 {
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530760 // Each record in the VPD becomes an interface and all
761 // keyword within the record are properties under that
762 // interface.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530763 for (const auto& record : vpdMap)
764 {
765 populateFruSpecificInterfaces(
SunnySrivastava1984e12b1812020-05-26 02:23:11 -0500766 record.second, ipzVpdInf + record.first, interfaces);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530767 }
768 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500769 else if constexpr (is_same<T, KeywordVpdMap>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530770 {
SunnySrivastava1984e12b1812020-05-26 02:23:11 -0500771 populateFruSpecificInterfaces(vpdMap, kwdVpdInf, interfaces);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530772 }
Santosh Puranik88edeb62020-03-02 12:00:09 +0530773 if (js.find("commonInterfaces") != js.end())
774 {
775 populateInterfaces(js["commonInterfaces"], interfaces, vpdMap,
776 isSystemVpd);
777 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530778 }
Santosh Puranik0859eb62020-03-16 02:56:29 -0500779 else
780 {
781 // Check if we have been asked to inherit specific record(s)
Alpana Kumari58e22142020-05-05 00:22:12 -0500782 if constexpr (is_same<T, Parsed>::value)
Santosh Puranik0859eb62020-03-16 02:56:29 -0500783 {
784 if (item.find("copyRecords") != item.end())
785 {
786 for (const auto& record : item["copyRecords"])
787 {
788 const string& recordName = record;
789 if (vpdMap.find(recordName) != vpdMap.end())
790 {
791 populateFruSpecificInterfaces(
SunnySrivastava1984e12b1812020-05-26 02:23:11 -0500792 vpdMap.at(recordName), ipzVpdInf + recordName,
Santosh Puranik0859eb62020-03-16 02:56:29 -0500793 interfaces);
794 }
795 }
796 }
797 }
798 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500799 if (item.value("inheritEI", true))
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530800 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500801 // Populate interfaces and properties that are common to every FRU
802 // and additional interface that might be defined on a per-FRU
803 // basis.
804 if (item.find("extraInterfaces") != item.end())
805 {
806 populateInterfaces(item["extraInterfaces"], interfaces, vpdMap,
807 isSystemVpd);
808 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530809 }
810 objects.emplace(move(object), move(interfaces));
811 }
812
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530813 if (isSystemVpd)
814 {
Santosh Puranikd278df12021-05-10 15:51:42 +0530815 string systemJsonName{};
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +0530816 if constexpr (is_same<T, Parsed>::value)
817 {
Alpana Kumarif05effd2021-04-07 07:32:53 -0500818 // pick the right system json
Santosh Puranikd278df12021-05-10 15:51:42 +0530819 systemJsonName = getSystemsJson(vpdMap);
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +0530820 }
821
Santosh Puranikd278df12021-05-10 15:51:42 +0530822 fs::path target = systemJsonName;
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +0530823 fs::path link = INVENTORY_JSON_SYM_LINK;
824
Santosh Puranik0246a4d2020-11-04 16:57:39 +0530825 // Create the directory for hosting the symlink
826 fs::create_directories(VPD_FILES_PATH);
827 // unlink the symlink previously created (if any)
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +0530828 remove(INVENTORY_JSON_SYM_LINK);
829 // create a new symlink based on the system
830 fs::create_symlink(target, link);
831
832 // Reloading the json
833 ifstream inventoryJson(link);
834 auto js = json::parse(inventoryJson);
835 inventoryJson.close();
836
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530837 inventory::ObjectMap primeObject = primeInventory(js, vpdMap);
838 objects.insert(primeObject.begin(), primeObject.end());
Alpana Kumari65b83602020-09-01 00:24:56 -0500839
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500840 // if system VPD has been restored at standby, update the EEPROM
841 for (const auto& item : updatedEeproms)
842 {
843 updateHardware(get<0>(item), get<1>(item), get<2>(item),
844 get<3>(item));
845 }
Alpana Kumarif05effd2021-04-07 07:32:53 -0500846
847 // set the U-boot environment variable for device-tree
848 if constexpr (is_same<T, Parsed>::value)
849 {
850 const string imKeyword = getIM(vpdMap);
851 const string hwKeyword = getHW(vpdMap);
852 string systemType = imKeyword;
853
854 // check If system has constraint then append HW version to it.
855 ifstream sysJson(SYSTEM_JSON);
856 if (!sysJson)
857 {
858 throw((VpdJsonException("Failed to access Json path",
859 SYSTEM_JSON)));
860 }
861
862 try
863 {
864 auto systemJson = json::parse(sysJson);
Santosh Puranikd278df12021-05-10 15:51:42 +0530865 if (systemJson["system"].find(imKeyword) !=
866 systemJson["system"].end())
867 {
868 if (systemJson["system"][imKeyword].find("constraint") !=
869 systemJson["system"][imKeyword].end())
870 {
871 systemType += "_" + hwKeyword;
872 }
873 }
Alpana Kumarif05effd2021-04-07 07:32:53 -0500874 }
875 catch (json::parse_error& ex)
876 {
877 throw((VpdJsonException("System Json parsing failed",
878 SYSTEM_JSON)));
879 }
880
Alpana Kumarif05effd2021-04-07 07:32:53 -0500881 setDevTreeEnv(systemType);
882 }
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530883 }
884
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530885 // Notify PIM
Sunny Srivastava6c71c9d2021-04-15 04:43:54 -0500886 common::utility::callPIM(move(objects));
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530887}
888
889int main(int argc, char** argv)
890{
891 int rc = 0;
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500892 json js{};
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -0600893 Binary vpdVector{};
894 string file{};
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500895 // map to hold additional data in case of logging pel
896 PelAdditionalData additionalData{};
897
898 // this is needed to hold base fru inventory path in case there is ECC or
899 // vpd exception while parsing the file
900 std::string baseFruInventoryPath = {};
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530901
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500902 // severity for PEL
903 PelSeverity pelSeverity = PelSeverity::WARNING;
904
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530905 try
906 {
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530907 App app{"ibm-read-vpd - App to read IPZ format VPD, parse it and store "
908 "in DBUS"};
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530909
910 app.add_option("-f, --file", file, "File containing VPD (IPZ/KEYWORD)")
Alpana Kumari2f793042020-08-18 05:51:03 -0500911 ->required();
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530912
913 CLI11_PARSE(app, argc, argv);
914
Santosh Puranik12e24ff2021-05-11 19:33:50 +0530915 cout << "Parser launched with file: " << file << "\n";
916
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500917 // PEL severity should be ERROR in case of any system VPD failure
918 if (file == systemVpdFilePath)
919 {
920 pelSeverity = PelSeverity::ERROR;
921 }
922
Santosh Puranik0246a4d2020-11-04 16:57:39 +0530923 auto jsonToParse = INVENTORY_JSON_DEFAULT;
924
925 // If the symlink exists, it means it has been setup for us, switch the
926 // path
927 if (fs::exists(INVENTORY_JSON_SYM_LINK))
928 {
929 jsonToParse = INVENTORY_JSON_SYM_LINK;
930 }
931
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530932 // Make sure that the file path we get is for a supported EEPROM
Santosh Puranik0246a4d2020-11-04 16:57:39 +0530933 ifstream inventoryJson(jsonToParse);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500934 if (!inventoryJson)
935 {
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500936 throw(VpdJsonException("Failed to access Json path", jsonToParse));
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500937 }
938
939 try
940 {
941 js = json::parse(inventoryJson);
942 }
943 catch (json::parse_error& ex)
944 {
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500945 throw(VpdJsonException("Json parsing failed", jsonToParse));
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500946 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530947
Santosh Puranik12e24ff2021-05-11 19:33:50 +0530948 // Do we have the mandatory "frus" section?
949 if (js.find("frus") == js.end())
950 {
951 throw(VpdJsonException("FRUs section not found in JSON",
952 jsonToParse));
953 }
954
PriyangaRamasamy647868e2020-09-08 17:03:19 +0530955 // Check if it's a udev path - patterned as(/ahb/ahb:apb/ahb:apb:bus@)
956 if (file.find("/ahb:apb") != string::npos)
957 {
958 // Translate udev path to a generic /sys/bus/.. file path.
959 udevToGenericPath(file);
Santosh Puranik12e24ff2021-05-11 19:33:50 +0530960 cout << "Path after translation: " << file << "\n";
961
962 if ((js["frus"].find(file) != js["frus"].end()) &&
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530963 (file == systemVpdFilePath))
PriyangaRamasamy647868e2020-09-08 17:03:19 +0530964 {
965 return 0;
966 }
967 }
968
969 if (file.empty())
970 {
971 cerr << "The EEPROM path <" << file << "> is not valid.";
972 return 0;
973 }
Santosh Puranik12e24ff2021-05-11 19:33:50 +0530974 if (js["frus"].find(file) == js["frus"].end())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530975 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500976 cout << "Device path not in JSON, ignoring" << endl;
Santosh Puranik88edeb62020-03-02 12:00:09 +0530977 return 0;
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530978 }
979
Alpana Kumari2f793042020-08-18 05:51:03 -0500980 if (!fs::exists(file))
981 {
982 cout << "Device path: " << file
983 << " does not exist. Spurious udev event? Exiting." << endl;
984 return 0;
985 }
986
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500987 baseFruInventoryPath = js["frus"][file][0]["inventoryPath"];
Santosh Puranik85893752020-11-10 21:31:43 +0530988 // Check if we can read the VPD file based on the power state
989 if (js["frus"][file].at(0).value("powerOffOnly", false))
990 {
991 if ("xyz.openbmc_project.State.Chassis.PowerState.On" ==
992 getPowerState())
993 {
994 cout << "This VPD cannot be read when power is ON" << endl;
995 return 0;
996 }
997 }
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -0500998
Alpana Kumari2f793042020-08-18 05:51:03 -0500999 try
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301000 {
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001001 vpdVector = getVpdDataInVector(js, file);
PriyangaRamasamy33c61c22021-04-06 11:15:57 -05001002 ParserInterface* parser = ParserFactory::getParser(vpdVector);
Alpana Kumari2f793042020-08-18 05:51:03 -05001003 variant<KeywordVpdMap, Store> parseResult;
1004 parseResult = parser->parse();
SunnySrivastava19849a195542020-09-07 06:04:50 -05001005
Alpana Kumari2f793042020-08-18 05:51:03 -05001006 if (auto pVal = get_if<Store>(&parseResult))
1007 {
1008 populateDbus(pVal->getVpdMap(), js, file);
1009 }
1010 else if (auto pVal = get_if<KeywordVpdMap>(&parseResult))
1011 {
1012 populateDbus(*pVal, js, file);
1013 }
1014
1015 // release the parser object
1016 ParserFactory::freeParser(parser);
1017 }
1018 catch (exception& e)
1019 {
1020 postFailAction(js, file);
PriyangaRamasamya504c3e2020-12-06 12:14:52 -06001021 throw;
Alpana Kumari2f793042020-08-18 05:51:03 -05001022 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301023 }
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001024 catch (const VpdJsonException& ex)
1025 {
1026 additionalData.emplace("JSON_PATH", ex.getJsonPath());
1027 additionalData.emplace("DESCRIPTION", ex.what());
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001028 createPEL(additionalData, pelSeverity, errIntfForJsonFailure);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001029
1030 cerr << ex.what() << "\n";
1031 rc = -1;
1032 }
1033 catch (const VpdEccException& ex)
1034 {
1035 additionalData.emplace("DESCRIPTION", "ECC check failed");
1036 additionalData.emplace("CALLOUT_INVENTORY_PATH",
1037 INVENTORY_PATH + baseFruInventoryPath);
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001038 createPEL(additionalData, pelSeverity, errIntfForEccCheckFail);
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001039 dumpBadVpd(file, vpdVector);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001040 cerr << ex.what() << "\n";
1041 rc = -1;
1042 }
1043 catch (const VpdDataException& ex)
1044 {
1045 additionalData.emplace("DESCRIPTION", "Invalid VPD data");
1046 additionalData.emplace("CALLOUT_INVENTORY_PATH",
1047 INVENTORY_PATH + baseFruInventoryPath);
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001048 createPEL(additionalData, pelSeverity, errIntfForInvalidVPD);
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001049 dumpBadVpd(file, vpdVector);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001050 cerr << ex.what() << "\n";
1051 rc = -1;
1052 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301053 catch (exception& e)
1054 {
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001055 dumpBadVpd(file, vpdVector);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301056 cerr << e.what() << "\n";
1057 rc = -1;
1058 }
1059
1060 return rc;
Joel Stanley6fb0ef92021-05-26 13:14:32 +09301061}