blob: feacc384dc5718f1449458fb408729a831a886a7 [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>
alpana077ce68722021-07-25 13:23:59 -050017#include <boost/algorithm/string.hpp>
Alpana Kumari65b83602020-09-01 00:24:56 -050018#include <cstdarg>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053019#include <exception>
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +053020#include <filesystem>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053021#include <fstream>
Alpana Kumari2f793042020-08-18 05:51:03 -050022#include <gpiod.hpp>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053023#include <iostream>
24#include <iterator>
25#include <nlohmann/json.hpp>
Andrew Geissler280197e2020-12-08 20:51:49 -060026#include <phosphor-logging/log.hpp>
alpana077ce68722021-07-25 13:23:59 -050027#include <regex>
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053028
29using namespace std;
30using namespace openpower::vpd;
31using namespace CLI;
32using namespace vpd::keyword::parser;
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +053033using namespace openpower::vpd::constants;
34namespace fs = filesystem;
35using json = nlohmann::json;
SunnySrivastava1984e12b1812020-05-26 02:23:11 -050036using namespace openpower::vpd::parser::factory;
SunnySrivastava1984945a02d2020-05-06 01:55:41 -050037using namespace openpower::vpd::inventory;
Alpana Kumaria00936f2020-04-14 07:15:46 -050038using namespace openpower::vpd::memory::parser;
SunnySrivastava1984e12b1812020-05-26 02:23:11 -050039using namespace openpower::vpd::parser::interface;
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -050040using namespace openpower::vpd::exceptions;
Andrew Geissler280197e2020-12-08 20:51:49 -060041using namespace phosphor::logging;
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +053042
Alpana Kumari65b83602020-09-01 00:24:56 -050043static const deviceTreeMap deviceTreeSystemTypeMap = {
Joel Stanley6fb0ef92021-05-26 13:14:32 +093044 {RAINIER_2U, "conf-aspeed-bmc-ibm-rainier-p1.dtb"},
45 {RAINIER_2U_V2, "conf-aspeed-bmc-ibm-rainier.dtb"},
46 {RAINIER_4U, "conf-aspeed-bmc-ibm-rainier-4u-p1.dtb"},
47 {RAINIER_4U_V2, "conf-aspeed-bmc-ibm-rainier-4u.dtb"},
Andrew Geissler2fe709f2021-03-25 10:59:07 -050048 {RAINIER_1S4U, "conf-aspeed-bmc-ibm-rainier-1s4u.dtb"},
49 {EVEREST, "conf-aspeed-bmc-ibm-everest.dtb"}};
Alpana Kumari65b83602020-09-01 00:24:56 -050050
Santosh Puranik88edeb62020-03-02 12:00:09 +053051/**
Santosh Puranik85893752020-11-10 21:31:43 +053052 * @brief Returns the power state for chassis0
53 */
54static auto getPowerState()
55{
56 // TODO: How do we handle multiple chassis?
57 string powerState{};
58 auto bus = sdbusplus::bus::new_default();
59 auto properties =
60 bus.new_method_call("xyz.openbmc_project.State.Chassis",
61 "/xyz/openbmc_project/state/chassis0",
62 "org.freedesktop.DBus.Properties", "Get");
63 properties.append("xyz.openbmc_project.State.Chassis");
64 properties.append("CurrentPowerState");
65 auto result = bus.call(properties);
66 if (!result.is_method_error())
67 {
68 variant<string> val;
69 result.read(val);
70 if (auto pVal = get_if<string>(&val))
71 {
72 powerState = *pVal;
73 }
74 }
75 cout << "Power state is: " << powerState << endl;
76 return powerState;
77}
78
79/**
Santosh Puranik88edeb62020-03-02 12:00:09 +053080 * @brief Expands location codes
81 */
82static auto expandLocationCode(const string& unexpanded, const Parsed& vpdMap,
83 bool isSystemVpd)
84{
85 auto expanded{unexpanded};
86 static constexpr auto SYSTEM_OBJECT = "/system/chassis/motherboard";
87 static constexpr auto VCEN_IF = "com.ibm.ipzvpd.VCEN";
88 static constexpr auto VSYS_IF = "com.ibm.ipzvpd.VSYS";
89 size_t idx = expanded.find("fcs");
90 try
91 {
92 if (idx != string::npos)
93 {
94 string fc{};
95 string se{};
96 if (isSystemVpd)
97 {
98 const auto& fcData = vpdMap.at("VCEN").at("FC");
99 const auto& seData = vpdMap.at("VCEN").at("SE");
100 fc = string(fcData.data(), fcData.size());
101 se = string(seData.data(), seData.size());
102 }
103 else
104 {
105 fc = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "FC");
106 se = readBusProperty(SYSTEM_OBJECT, VCEN_IF, "SE");
107 }
108
Alpana Kumari81671f62021-02-10 02:21:59 -0600109 // TODO: See if ND0 can be placed in the JSON
110 expanded.replace(idx, 3, fc.substr(0, 4) + ".ND0." + se);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530111 }
112 else
113 {
114 idx = expanded.find("mts");
115 if (idx != string::npos)
116 {
117 string mt{};
118 string se{};
119 if (isSystemVpd)
120 {
121 const auto& mtData = vpdMap.at("VSYS").at("TM");
122 const auto& seData = vpdMap.at("VSYS").at("SE");
123 mt = string(mtData.data(), mtData.size());
124 se = string(seData.data(), seData.size());
125 }
126 else
127 {
128 mt = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "TM");
129 se = readBusProperty(SYSTEM_OBJECT, VSYS_IF, "SE");
130 }
131
132 replace(mt.begin(), mt.end(), '-', '.');
133 expanded.replace(idx, 3, mt + "." + se);
134 }
135 }
136 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500137 catch (exception& e)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530138 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500139 cerr << "Failed to expand location code with exception: " << e.what()
140 << "\n";
Santosh Puranik88edeb62020-03-02 12:00:09 +0530141 }
142 return expanded;
143}
Alpana Kumari2f793042020-08-18 05:51:03 -0500144
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530145/**
146 * @brief Populate FRU specific interfaces.
147 *
148 * This is a common method which handles both
149 * ipz and keyword specific interfaces thus,
150 * reducing the code redundancy.
151 * @param[in] map - Reference to the innermost keyword-value map.
152 * @param[in] preIntrStr - Reference to the interface string.
153 * @param[out] interfaces - Reference to interface map.
154 */
155template <typename T>
156static void populateFruSpecificInterfaces(const T& map,
157 const string& preIntrStr,
158 inventory::InterfaceMap& interfaces)
159{
160 inventory::PropertyMap prop;
161
162 for (const auto& kwVal : map)
163 {
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530164 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 }
Alpana Kumari3ab26a72021-04-05 19:09:19 +0000174 if constexpr (is_same<T, KeywordVpdMap>::value)
175 {
176 if (get_if<Binary>(&kwVal.second))
177 {
178 Binary vec(get_if<Binary>(&kwVal.second)->begin(),
179 get_if<Binary>(&kwVal.second)->end());
Alpana Kumari3ab26a72021-04-05 19:09:19 +0000180 prop.emplace(move(kw), move(vec));
181 }
182 else
183 {
184 if (kw == "MemorySizeInKB")
185 {
186 inventory::PropertyMap memProp;
187 auto memVal = get_if<size_t>(&kwVal.second);
188 if (memVal)
189 {
190 memProp.emplace(move(kw),
191 ((*memVal) * CONVERT_MB_TO_KB));
192 interfaces.emplace(
193 "xyz.openbmc_project.Inventory.Item.Dimm",
194 move(memProp));
195 }
196 else
197 {
198 cerr << "MemorySizeInKB value not found in vpd map\n";
199 }
200 }
201 }
202 }
203 else
204 {
205 Binary vec(kwVal.second.begin(), kwVal.second.end());
206 prop.emplace(move(kw), move(vec));
207 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530208 }
209
210 interfaces.emplace(preIntrStr, move(prop));
211}
212
213/**
214 * @brief Populate Interfaces.
215 *
216 * This method populates common and extra interfaces to dbus.
217 * @param[in] js - json object
218 * @param[out] interfaces - Reference to interface map
219 * @param[in] vpdMap - Reference to the parsed vpd map.
Santosh Puranik88edeb62020-03-02 12:00:09 +0530220 * @param[in] isSystemVpd - Denotes whether we are collecting the system VPD.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530221 */
222template <typename T>
223static void populateInterfaces(const nlohmann::json& js,
224 inventory::InterfaceMap& interfaces,
Santosh Puranik88edeb62020-03-02 12:00:09 +0530225 const T& vpdMap, bool isSystemVpd)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530226{
227 for (const auto& ifs : js.items())
228 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530229 string inf = ifs.key();
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530230 inventory::PropertyMap props;
231
232 for (const auto& itr : ifs.value().items())
233 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530234 const string& busProp = itr.key();
235
Alpana Kumari31970de2020-02-17 06:49:57 -0600236 if (itr.value().is_boolean())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530237 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530238 props.emplace(busProp, itr.value().get<bool>());
239 }
240 else if (itr.value().is_string())
241 {
Alpana Kumari58e22142020-05-05 00:22:12 -0500242 if constexpr (is_same<T, Parsed>::value)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530243 {
244 if (busProp == "LocationCode" &&
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000245 inf == IBM_LOCATION_CODE_INF)
Santosh Puranik88edeb62020-03-02 12:00:09 +0530246 {
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000247 // TODO deprecate the com.ibm interface later
Santosh Puranik88edeb62020-03-02 12:00:09 +0530248 auto prop = expandLocationCode(
249 itr.value().get<string>(), vpdMap, isSystemVpd);
250 props.emplace(busProp, prop);
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000251 interfaces.emplace(XYZ_LOCATION_CODE_INF, props);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530252 }
253 else
254 {
255 props.emplace(busProp, itr.value().get<string>());
256 }
257 }
258 else
259 {
260 props.emplace(busProp, itr.value().get<string>());
261 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530262 }
Santosh Puraniked609af2021-06-21 11:30:07 +0530263 else if (itr.value().is_array())
264 {
265 try
266 {
267 props.emplace(busProp, itr.value().get<Binary>());
268 }
269 catch (nlohmann::detail::type_error& e)
270 {
271 std::cerr << "Type exception: " << e.what() << "\n";
272 // Ignore any type errors
273 }
274 }
Alpana Kumari31970de2020-02-17 06:49:57 -0600275 else if (itr.value().is_object())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530276 {
Alpana Kumari31970de2020-02-17 06:49:57 -0600277 const string& rec = itr.value().value("recordName", "");
278 const string& kw = itr.value().value("keywordName", "");
279 const string& encoding = itr.value().value("encoding", "");
280
Alpana Kumari58e22142020-05-05 00:22:12 -0500281 if constexpr (is_same<T, Parsed>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530282 {
Santosh Puranik88edeb62020-03-02 12:00:09 +0530283 if (!rec.empty() && !kw.empty() && vpdMap.count(rec) &&
284 vpdMap.at(rec).count(kw))
Alpana Kumari31970de2020-02-17 06:49:57 -0600285 {
286 auto encoded =
287 encodeKeyword(vpdMap.at(rec).at(kw), encoding);
Santosh Puranik88edeb62020-03-02 12:00:09 +0530288 props.emplace(busProp, encoded);
Alpana Kumari31970de2020-02-17 06:49:57 -0600289 }
290 }
Alpana Kumari58e22142020-05-05 00:22:12 -0500291 else if constexpr (is_same<T, KeywordVpdMap>::value)
Alpana Kumari31970de2020-02-17 06:49:57 -0600292 {
293 if (!kw.empty() && vpdMap.count(kw))
294 {
Alpana Kumari3ab26a72021-04-05 19:09:19 +0000295 auto kwValue = get_if<Binary>(&vpdMap.at(kw));
296 auto uintValue = get_if<size_t>(&vpdMap.at(kw));
297
298 if (kwValue)
299 {
300 auto prop =
301 string((*kwValue).begin(), (*kwValue).end());
302
303 auto encoded = encodeKeyword(prop, encoding);
304
305 props.emplace(busProp, encoded);
306 }
307 else if (uintValue)
308 {
309 props.emplace(busProp, *uintValue);
310 }
Alpana Kumari31970de2020-02-17 06:49:57 -0600311 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530312 }
313 }
Matt Spinlerb1e64bb2021-09-08 09:57:48 -0500314 else if (itr.value().is_number())
315 {
316 // For now assume the value is a size_t. In the future it would
317 // be nice to come up with a way to get the type from the JSON.
318 props.emplace(busProp, itr.value().get<size_t>());
319 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530320 }
321 interfaces.emplace(inf, move(props));
322 }
323}
324
Alpana Kumari2f793042020-08-18 05:51:03 -0500325static Binary getVpdDataInVector(const nlohmann::json& js, const string& file)
Alpana Kumari58e22142020-05-05 00:22:12 -0500326{
327 uint32_t offset = 0;
328 // check if offset present?
329 for (const auto& item : js["frus"][file])
330 {
331 if (item.find("offset") != item.end())
332 {
333 offset = item["offset"];
334 }
335 }
336
337 // TODO: Figure out a better way to get max possible VPD size.
338 Binary vpdVector;
339 vpdVector.resize(65504);
340 ifstream vpdFile;
341 vpdFile.open(file, ios::binary);
342
343 vpdFile.seekg(offset, ios_base::cur);
344 vpdFile.read(reinterpret_cast<char*>(&vpdVector[0]), 65504);
345 vpdVector.resize(vpdFile.gcount());
346
347 return vpdVector;
348}
349
Alpana Kumari2f793042020-08-18 05:51:03 -0500350/** This API will be called at the end of VPD collection to perform any post
351 * actions.
352 *
353 * @param[in] json - json object
354 * @param[in] file - eeprom file path
355 */
356static void postFailAction(const nlohmann::json& json, const string& file)
357{
358 if ((json["frus"][file].at(0)).find("postActionFail") ==
359 json["frus"][file].at(0).end())
360 {
361 return;
362 }
363
364 uint8_t pinValue = 0;
365 string pinName;
366
367 for (const auto& postAction :
368 (json["frus"][file].at(0))["postActionFail"].items())
369 {
370 if (postAction.key() == "pin")
371 {
372 pinName = postAction.value();
373 }
374 else if (postAction.key() == "value")
375 {
376 // Get the value to set
377 pinValue = postAction.value();
378 }
379 }
380
381 cout << "Setting GPIO: " << pinName << " to " << (int)pinValue << endl;
382
383 try
384 {
385 gpiod::line outputLine = gpiod::find_line(pinName);
386
387 if (!outputLine)
388 {
389 cout << "Couldn't find output line:" << pinName
390 << " on GPIO. Skipping...\n";
391
392 return;
393 }
394 outputLine.request(
395 {"Disable line", ::gpiod::line_request::DIRECTION_OUTPUT, 0},
396 pinValue);
397 }
398 catch (system_error&)
399 {
400 cerr << "Failed to set post-action GPIO" << endl;
401 }
402}
403
404/** Performs any pre-action needed to get the FRU setup for collection.
405 *
406 * @param[in] json - json object
407 * @param[in] file - eeprom file path
408 */
409static void preAction(const nlohmann::json& json, const string& file)
410{
411 if ((json["frus"][file].at(0)).find("preAction") ==
412 json["frus"][file].at(0).end())
413 {
414 return;
415 }
416
417 uint8_t pinValue = 0;
418 string pinName;
419
420 for (const auto& postAction :
421 (json["frus"][file].at(0))["preAction"].items())
422 {
423 if (postAction.key() == "pin")
424 {
425 pinName = postAction.value();
426 }
427 else if (postAction.key() == "value")
428 {
429 // Get the value to set
430 pinValue = postAction.value();
431 }
432 }
433
434 cout << "Setting GPIO: " << pinName << " to " << (int)pinValue << endl;
435 try
436 {
437 gpiod::line outputLine = gpiod::find_line(pinName);
438
439 if (!outputLine)
440 {
441 cout << "Couldn't find output line:" << pinName
442 << " on GPIO. Skipping...\n";
443
444 return;
445 }
446 outputLine.request(
447 {"FRU pre-action", ::gpiod::line_request::DIRECTION_OUTPUT, 0},
448 pinValue);
449 }
450 catch (system_error&)
451 {
452 cerr << "Failed to set pre-action GPIO" << endl;
453 return;
454 }
455
456 // Now bind the device
Alpana Kumari4c3bf5b2021-09-16 07:24:58 -0500457 string bind = json["frus"][file].at(0).value("devAddress", "");
Alpana Kumari2f793042020-08-18 05:51:03 -0500458 cout << "Binding device " << bind << endl;
459 string bindCmd = string("echo \"") + bind +
460 string("\" > /sys/bus/i2c/drivers/at24/bind");
461 cout << bindCmd << endl;
462 executeCmd(bindCmd);
463
464 // Check if device showed up (test for file)
465 if (!fs::exists(file))
466 {
467 cout << "EEPROM " << file << " does not exist. Take failure action"
468 << endl;
469 // If not, then take failure postAction
470 postFailAction(json, file);
471 }
472}
473
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530474/**
Santosh Puranikd3a379a2021-08-23 19:12:59 +0530475 * @brief Set certain one time properties in the inventory
476 * Use this function to insert the Functional and Enabled properties into the
477 * inventory map. This function first checks if the object in question already
478 * has these properties hosted on D-Bus, if the property is already there, it is
479 * not modified, hence the name "one time". If the property is not already
480 * present, it will be added to the map with a suitable default value (true for
481 * Functional and false for Enabled)
482 *
483 * @param[in] object - The inventory D-Bus obejct without the inventory prefix.
484 * @param[inout] interfaces - Reference to a map of inventory interfaces to
485 * which the properties will be attached.
486 */
487static void setOneTimeProperties(const std::string& object,
488 inventory::InterfaceMap& interfaces)
489{
490 auto bus = sdbusplus::bus::new_default();
491 auto objectPath = INVENTORY_PATH + object;
492 auto prop = bus.new_method_call("xyz.openbmc_project.Inventory.Manager",
493 objectPath.c_str(),
494 "org.freedesktop.DBus.Properties", "Get");
495 prop.append("xyz.openbmc_project.State.Decorator.OperationalStatus");
496 prop.append("Functional");
497 try
498 {
499 auto result = bus.call(prop);
500 }
501 catch (const sdbusplus::exception::SdBusError& e)
502 {
503 // Treat as property unavailable
504 inventory::PropertyMap prop;
505 prop.emplace("Functional", true);
506 interfaces.emplace(
507 "xyz.openbmc_project.State.Decorator.OperationalStatus",
508 move(prop));
509 }
510 prop = bus.new_method_call("xyz.openbmc_project.Inventory.Manager",
511 objectPath.c_str(),
512 "org.freedesktop.DBus.Properties", "Get");
513 prop.append("xyz.openbmc_project.Object.Enable");
514 prop.append("Enabled");
515 try
516 {
517 auto result = bus.call(prop);
518 }
519 catch (const sdbusplus::exception::SdBusError& e)
520 {
521 // Treat as property unavailable
522 inventory::PropertyMap prop;
523 prop.emplace("Enabled", false);
524 interfaces.emplace("xyz.openbmc_project.Object.Enable", move(prop));
525 }
526}
527
528/**
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530529 * @brief Prime the Inventory
530 * Prime the inventory by populating only the location code,
531 * type interface and the inventory object for the frus
532 * which are not system vpd fru.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530533 *
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530534 * @param[in] jsObject - Reference to vpd inventory json object
535 * @param[in] vpdMap - Reference to the parsed vpd map
536 *
537 * @returns Map of items in extraInterface.
538 */
539template <typename T>
540inventory::ObjectMap primeInventory(const nlohmann::json& jsObject,
541 const T& vpdMap)
542{
543 inventory::ObjectMap objects;
544
545 for (auto& itemFRUS : jsObject["frus"].items())
546 {
Alpana Kumari2f793042020-08-18 05:51:03 -0500547 // Take pre actions
548 preAction(jsObject, itemFRUS.key());
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530549 for (auto& itemEEPROM : itemFRUS.value())
550 {
551 inventory::InterfaceMap interfaces;
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530552 inventory::Object object(itemEEPROM.at("inventoryPath"));
553
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530554 if ((itemFRUS.key() != systemVpdFilePath) &&
555 !itemEEPROM.value("noprime", false))
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530556 {
Alpana Kumaricfd7a752021-02-07 23:23:01 -0600557 inventory::PropertyMap presProp;
558 presProp.emplace("Present", false);
559 interfaces.emplace("xyz.openbmc_project.Inventory.Item",
Santosh Puranikd3a379a2021-08-23 19:12:59 +0530560 presProp);
561 setOneTimeProperties(object, interfaces);
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530562 if (itemEEPROM.find("extraInterfaces") != itemEEPROM.end())
563 {
564 for (const auto& eI : itemEEPROM["extraInterfaces"].items())
565 {
566 inventory::PropertyMap props;
Alpana Kumari414d5ae2021-03-04 21:06:35 +0000567 if (eI.key() == IBM_LOCATION_CODE_INF)
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530568 {
569 if constexpr (std::is_same<T, Parsed>::value)
570 {
571 for (auto& lC : eI.value().items())
572 {
573 auto propVal = expandLocationCode(
574 lC.value().get<string>(), vpdMap, true);
575
576 props.emplace(move(lC.key()),
577 move(propVal));
Santosh Puranikb0f37492021-06-21 09:42:47 +0530578 interfaces.emplace(XYZ_LOCATION_CODE_INF,
579 props);
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530580 interfaces.emplace(move(eI.key()),
581 move(props));
582 }
583 }
584 }
585 else if (eI.key().find("Inventory.Item.") !=
586 string::npos)
587 {
588 interfaces.emplace(move(eI.key()), move(props));
589 }
Santosh Puranikd3a379a2021-08-23 19:12:59 +0530590 else if (eI.key() ==
591 "xyz.openbmc_project.Inventory.Item")
592 {
593 for (auto& val : eI.value().items())
594 {
595 if (val.key() == "PrettyName")
596 {
597 presProp.emplace(val.key(),
598 val.value().get<string>());
599 }
600 }
601 // Use insert_or_assign here as we may already have
602 // inserted the present property only earlier in
603 // this function under this same interface.
604 interfaces.insert_or_assign(eI.key(),
605 move(presProp));
606 }
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530607 }
608 }
609 objects.emplace(move(object), move(interfaces));
610 }
611 }
612 }
613 return objects;
614}
615
Alpana Kumari65b83602020-09-01 00:24:56 -0500616/**
617 * @brief This API executes command to set environment variable
618 * And then reboot the system
619 * @param[in] key -env key to set new value
620 * @param[in] value -value to set.
621 */
622void setEnvAndReboot(const string& key, const string& value)
623{
624 // set env and reboot and break.
625 executeCmd("/sbin/fw_setenv", key, value);
Andrew Geissler280197e2020-12-08 20:51:49 -0600626 log<level::INFO>("Rebooting BMC to pick up new device tree");
Alpana Kumari65b83602020-09-01 00:24:56 -0500627 // make dbus call to reboot
628 auto bus = sdbusplus::bus::new_default_system();
629 auto method = bus.new_method_call(
630 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
631 "org.freedesktop.systemd1.Manager", "Reboot");
632 bus.call_noreply(method);
633}
634
635/*
636 * @brief This API checks for env var fitconfig.
637 * If not initialised OR updated as per the current system type,
638 * update this env var and reboot the system.
639 *
640 * @param[in] systemType IM kwd in vpd tells about which system type it is.
641 * */
642void setDevTreeEnv(const string& systemType)
643{
644 string newDeviceTree;
645
646 if (deviceTreeSystemTypeMap.find(systemType) !=
647 deviceTreeSystemTypeMap.end())
648 {
649 newDeviceTree = deviceTreeSystemTypeMap.at(systemType);
650 }
651
652 string readVarValue;
653 bool envVarFound = false;
654
655 vector<string> output = executeCmd("/sbin/fw_printenv");
656 for (const auto& entry : output)
657 {
658 size_t pos = entry.find("=");
659 string key = entry.substr(0, pos);
660 if (key != "fitconfig")
661 {
662 continue;
663 }
664
665 envVarFound = true;
666 if (pos + 1 < entry.size())
667 {
668 readVarValue = entry.substr(pos + 1);
669 if (readVarValue.find(newDeviceTree) != string::npos)
670 {
671 // fitconfig is Updated. No action needed
672 break;
673 }
674 }
675 // set env and reboot and break.
676 setEnvAndReboot(key, newDeviceTree);
677 exit(0);
678 }
679
680 // check If env var Not found
681 if (!envVarFound)
682 {
683 setEnvAndReboot("fitconfig", newDeviceTree);
684 }
685}
686
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530687/**
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500688 * @brief API to call VPD manager to write VPD to EEPROM.
689 * @param[in] Object path.
690 * @param[in] record to be updated.
691 * @param[in] keyword to be updated.
692 * @param[in] keyword data to be updated
693 */
694void updateHardware(const string& objectName, const string& recName,
695 const string& kwdName, const Binary& data)
696{
697 try
698 {
699 auto bus = sdbusplus::bus::new_default();
700 auto properties =
701 bus.new_method_call(BUSNAME, OBJPATH, IFACE, "WriteKeyword");
702 properties.append(
703 static_cast<sdbusplus::message::object_path>(objectName));
704 properties.append(recName);
705 properties.append(kwdName);
706 properties.append(data);
707 bus.call(properties);
708 }
Patrick Williams8be43342021-09-02 09:33:36 -0500709 catch (const sdbusplus::exception::exception& e)
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500710 {
711 std::string what =
712 "VPDManager WriteKeyword api failed for inventory path " +
713 objectName;
714 what += " record " + recName;
715 what += " keyword " + kwdName;
716 what += " with bus error = " + std::string(e.what());
717
718 // map to hold additional data in case of logging pel
719 PelAdditionalData additionalData{};
720 additionalData.emplace("CALLOUT_INVENTORY_PATH", objectName);
721 additionalData.emplace("DESCRIPTION", what);
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500722 createPEL(additionalData, PelSeverity::WARNING, errIntfForBusFailure);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500723 }
724}
725
726/**
727 * @brief API to check if we need to restore system VPD
728 * This functionality is only applicable for IPZ VPD data.
729 * @param[in] vpdMap - IPZ vpd map
730 * @param[in] objectPath - Object path for the FRU
731 * @return EEPROMs with records and keywords updated at standby
732 */
733std::vector<RestoredEeproms> restoreSystemVPD(Parsed& vpdMap,
734 const string& objectPath)
735{
736 // the list of keywords for VSYS record is as per the S0 system. Should be
737 // updated for another type of systems
738 static std::unordered_map<std::string, std::vector<std::string>> svpdKwdMap{
739 {"VSYS", {"BR", "TM", "SE", "SU", "RB"}},
740 {"VCEN", {"FC", "SE"}},
741 {"LXR0", {"LX"}}};
742
743 // vector to hold all the EEPROMs updated at standby
744 std::vector<RestoredEeproms> updatedEeproms = {};
745
746 for (const auto& systemRecKwdPair : svpdKwdMap)
747 {
748 auto it = vpdMap.find(systemRecKwdPair.first);
749
750 // check if record is found in map we got by parser
751 if (it != vpdMap.end())
752 {
753 const auto& kwdListForRecord = systemRecKwdPair.second;
754 for (const auto& keyword : kwdListForRecord)
755 {
756 DbusPropertyMap& kwdValMap = it->second;
757 auto iterator = kwdValMap.find(keyword);
758
759 if (iterator != kwdValMap.end())
760 {
761 string& kwdValue = iterator->second;
762
763 // check bus data
764 const string& recordName = systemRecKwdPair.first;
765 const string& busValue = readBusProperty(
766 objectPath, ipzVpdInf + recordName, keyword);
767
768 if (busValue.find_first_not_of(' ') != string::npos)
769 {
770 if (kwdValue.find_first_not_of(' ') != string::npos)
771 {
772 // both the data are present, check for mismatch
773 if (busValue != kwdValue)
774 {
775 string errMsg = "VPD data mismatch on cache "
776 "and hardware for record: ";
777 errMsg += (*it).first;
778 errMsg += " and keyword: ";
779 errMsg += keyword;
780
781 // data mismatch
782 PelAdditionalData additionalData;
783 additionalData.emplace("CALLOUT_INVENTORY_PATH",
784 objectPath);
785
786 additionalData.emplace("DESCRIPTION", errMsg);
787
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500788 createPEL(additionalData, PelSeverity::WARNING,
789 errIntfForInvalidVPD);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500790 }
791 }
792 else
793 {
794 // implies hardware data is blank
795 // update the map
796 Binary busData(busValue.begin(), busValue.end());
797
798 updatedEeproms.push_back(std::make_tuple(
799 objectPath, recordName, keyword, busData));
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500800
Sunny Srivastava90a63b92021-05-26 06:30:24 -0500801 // update the map as well, so that cache data is not
802 // updated as blank while populating VPD map on Dbus
803 // in populateDBus Api
804 kwdValue = busValue;
805 }
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500806 }
807 else if (kwdValue.find_first_not_of(' ') == string::npos)
808 {
809 string errMsg = "VPD is blank on both cache and "
810 "hardware for record: ";
811 errMsg += (*it).first;
812 errMsg += " and keyword: ";
813 errMsg += keyword;
814 errMsg += ". SSR need to update hardware VPD.";
815
816 // both the data are blanks, log PEL
817 PelAdditionalData additionalData;
818 additionalData.emplace("CALLOUT_INVENTORY_PATH",
819 objectPath);
820
821 additionalData.emplace("DESCRIPTION", errMsg);
822
823 // log PEL TODO: Block IPL
Sunny Srivastava0746eee2021-03-22 13:36:54 -0500824 createPEL(additionalData, PelSeverity::ERROR,
825 errIntfForBlankSystemVPD);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500826 continue;
827 }
828 }
829 }
830 }
831 }
832
833 return updatedEeproms;
834}
835
836/**
alpana077ce68722021-07-25 13:23:59 -0500837 * @brief This checks for is this FRU a processor
838 * And if yes, then checks for is this primary
839 *
840 * @param[in] js- vpd json to get the information about this FRU
841 * @param[in] filePath- FRU vpd
842 *
843 * @return true/false
844 */
845bool isThisPrimaryProcessor(nlohmann::json& js, const string& filePath)
846{
847 bool isProcessor = false;
848 bool isPrimary = false;
849
850 for (const auto& item : js["frus"][filePath])
851 {
852 if (item.find("extraInterfaces") != item.end())
853 {
854 for (const auto& eI : item["extraInterfaces"].items())
855 {
856 if (eI.key().find("Inventory.Item.Cpu") != string::npos)
857 {
858 isProcessor = true;
859 }
860 }
861 }
862
863 if (isProcessor)
864 {
865 string cpuType = item.value("cpuType", "");
866 if (cpuType == "primary")
867 {
868 isPrimary = true;
869 }
870 }
871 }
872
873 return (isProcessor && isPrimary);
874}
875
876/**
877 * @brief This finds DIMM vpd in vpd json and enables them by binding the device
878 * driver
879 * @param[in] js- vpd json to iterate through and take action if it is DIMM
880 */
881void doEnableAllDimms(nlohmann::json& js)
882{
883 // iterate over each fru
884 for (const auto& eachFru : js["frus"].items())
885 {
886 // skip the driver binding if eeprom already exists
887 if (fs::exists(eachFru.key()))
888 {
889 continue;
890 }
891
892 for (const auto& eachInventory : eachFru.value())
893 {
894 if (eachInventory.find("extraInterfaces") != eachInventory.end())
895 {
896 for (const auto& eI : eachInventory["extraInterfaces"].items())
897 {
898 if (eI.key().find("Inventory.Item.Dimm") != string::npos)
899 {
900 string dimmVpd = eachFru.key();
901 // fetch it from
902 // "/sys/bus/i2c/drivers/at24/414-0050/eeprom"
903
904 regex matchPatern("([0-9]+-[0-9]{4})");
905 smatch matchFound;
906 if (regex_search(dimmVpd, matchFound, matchPatern))
907 {
908 vector<string> i2cReg;
909 boost::split(i2cReg, matchFound.str(0),
910 boost::is_any_of("-"));
911
912 // remove 0s from begining
913 const regex pattern("^0+(?!$)");
914 for (auto& i : i2cReg)
915 {
916 i = regex_replace(i, pattern, "");
917 }
918
919 if (i2cReg.size() == 2)
920 {
921 // echo 24c32 0x50 >
922 // /sys/bus/i2c/devices/i2c-16/new_device
923 string cmnd = "echo 24c32 0x" + i2cReg[1] +
924 " > /sys/bus/i2c/devices/i2c-" +
925 i2cReg[0] + "/new_device";
926
927 executeCmd(cmnd);
928 }
929 }
930 }
931 }
932 }
933 }
934 }
935}
936
937/**
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530938 * @brief Populate Dbus.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530939 * This method invokes all the populateInterface functions
940 * and notifies PIM about dbus object.
PriyangaRamasamy8e140a12020-04-13 19:24:03 +0530941 * @param[in] vpdMap - Either IPZ vpd map or Keyword vpd map based on the
942 * input.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530943 * @param[in] js - Inventory json object
944 * @param[in] filePath - Path of the vpd file
945 * @param[in] preIntrStr - Interface string
946 */
947template <typename T>
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500948static void populateDbus(T& vpdMap, nlohmann::json& js, const string& filePath)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +0530949{
950 inventory::InterfaceMap interfaces;
951 inventory::ObjectMap objects;
952 inventory::PropertyMap prop;
953
SunnySrivastava19849094d4f2020-08-05 09:32:29 -0500954 // map to hold all the keywords whose value has been changed at standby
955 vector<RestoredEeproms> updatedEeproms = {};
956
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530957 bool isSystemVpd = (filePath == systemVpdFilePath);
958 if constexpr (is_same<T, Parsed>::value)
959 {
960 if (isSystemVpd)
961 {
962 std::vector<std::string> interfaces = {motherBoardInterface};
963 // call mapper to check for object path creation
964 MapperResponse subTree =
965 getObjectSubtreeForInterfaces(pimPath, 0, interfaces);
966 string mboardPath =
967 js["frus"][filePath].at(0).value("inventoryPath", "");
968
969 // Attempt system VPD restore if we have a motherboard
970 // object in the inventory.
971 if ((subTree.size() != 0) &&
972 (subTree.find(pimPath + mboardPath) != subTree.end()))
973 {
974 updatedEeproms = restoreSystemVPD(vpdMap, mboardPath);
975 }
976 else
977 {
978 log<level::ERR>("No object path found");
979 }
980 }
alpana077ce68722021-07-25 13:23:59 -0500981 else
982 {
983 // check if it is processor vpd.
984 auto isPrimaryCpu = isThisPrimaryProcessor(js, filePath);
985
986 if (isPrimaryCpu)
987 {
988 auto ddVersion = getKwVal(vpdMap, "CRP0", "DD");
989
990 auto chipVersion = atoi(ddVersion.substr(1, 2).c_str());
991
992 if (chipVersion >= 2)
993 {
994 doEnableAllDimms(js);
995 }
996 }
997 }
Santosh Puranik50f60bf2021-05-26 17:55:06 +0530998 }
999
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301000 for (const auto& item : js["frus"][filePath])
1001 {
1002 const auto& objectPath = item["inventoryPath"];
1003 sdbusplus::message::object_path object(objectPath);
SunnySrivastava19849094d4f2020-08-05 09:32:29 -05001004
Santosh Puranikd3a379a2021-08-23 19:12:59 +05301005 if (isSystemVpd)
1006 {
1007 // Populate one time properties for the system VPD and its sub-frus.
1008 // For the remaining FRUs, this will get handled as a part of
1009 // priming the inventory.
1010 setOneTimeProperties(objectPath, interfaces);
1011 }
1012
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301013 // Populate the VPD keywords and the common interfaces only if we
1014 // are asked to inherit that data from the VPD, else only add the
1015 // extraInterfaces.
1016 if (item.value("inherit", true))
1017 {
Alpana Kumari58e22142020-05-05 00:22:12 -05001018 if constexpr (is_same<T, Parsed>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301019 {
PriyangaRamasamy8e140a12020-04-13 19:24:03 +05301020 // Each record in the VPD becomes an interface and all
1021 // keyword within the record are properties under that
1022 // interface.
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301023 for (const auto& record : vpdMap)
1024 {
1025 populateFruSpecificInterfaces(
SunnySrivastava1984e12b1812020-05-26 02:23:11 -05001026 record.second, ipzVpdInf + record.first, interfaces);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301027 }
1028 }
Alpana Kumari58e22142020-05-05 00:22:12 -05001029 else if constexpr (is_same<T, KeywordVpdMap>::value)
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301030 {
SunnySrivastava1984e12b1812020-05-26 02:23:11 -05001031 populateFruSpecificInterfaces(vpdMap, kwdVpdInf, interfaces);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301032 }
Santosh Puranik88edeb62020-03-02 12:00:09 +05301033 if (js.find("commonInterfaces") != js.end())
1034 {
1035 populateInterfaces(js["commonInterfaces"], interfaces, vpdMap,
1036 isSystemVpd);
1037 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301038 }
Santosh Puranik0859eb62020-03-16 02:56:29 -05001039 else
1040 {
1041 // Check if we have been asked to inherit specific record(s)
Alpana Kumari58e22142020-05-05 00:22:12 -05001042 if constexpr (is_same<T, Parsed>::value)
Santosh Puranik0859eb62020-03-16 02:56:29 -05001043 {
1044 if (item.find("copyRecords") != item.end())
1045 {
1046 for (const auto& record : item["copyRecords"])
1047 {
1048 const string& recordName = record;
1049 if (vpdMap.find(recordName) != vpdMap.end())
1050 {
1051 populateFruSpecificInterfaces(
SunnySrivastava1984e12b1812020-05-26 02:23:11 -05001052 vpdMap.at(recordName), ipzVpdInf + recordName,
Santosh Puranik0859eb62020-03-16 02:56:29 -05001053 interfaces);
1054 }
1055 }
1056 }
1057 }
1058 }
Alpana Kumari58e22142020-05-05 00:22:12 -05001059 if (item.value("inheritEI", true))
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301060 {
Alpana Kumari58e22142020-05-05 00:22:12 -05001061 // Populate interfaces and properties that are common to every FRU
1062 // and additional interface that might be defined on a per-FRU
1063 // basis.
1064 if (item.find("extraInterfaces") != item.end())
1065 {
1066 populateInterfaces(item["extraInterfaces"], interfaces, vpdMap,
1067 isSystemVpd);
1068 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301069 }
1070 objects.emplace(move(object), move(interfaces));
1071 }
1072
PriyangaRamasamy8e140a12020-04-13 19:24:03 +05301073 if (isSystemVpd)
1074 {
Santosh Puranikd278df12021-05-10 15:51:42 +05301075 string systemJsonName{};
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +05301076 if constexpr (is_same<T, Parsed>::value)
1077 {
Alpana Kumarif05effd2021-04-07 07:32:53 -05001078 // pick the right system json
Santosh Puranikd278df12021-05-10 15:51:42 +05301079 systemJsonName = getSystemsJson(vpdMap);
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +05301080 }
1081
Santosh Puranikd278df12021-05-10 15:51:42 +05301082 fs::path target = systemJsonName;
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +05301083 fs::path link = INVENTORY_JSON_SYM_LINK;
1084
Santosh Puranik0246a4d2020-11-04 16:57:39 +05301085 // Create the directory for hosting the symlink
1086 fs::create_directories(VPD_FILES_PATH);
1087 // unlink the symlink previously created (if any)
PriyangaRamasamy83a1d5d2020-04-30 19:15:43 +05301088 remove(INVENTORY_JSON_SYM_LINK);
1089 // create a new symlink based on the system
1090 fs::create_symlink(target, link);
1091
1092 // Reloading the json
1093 ifstream inventoryJson(link);
1094 auto js = json::parse(inventoryJson);
1095 inventoryJson.close();
1096
PriyangaRamasamy8e140a12020-04-13 19:24:03 +05301097 inventory::ObjectMap primeObject = primeInventory(js, vpdMap);
1098 objects.insert(primeObject.begin(), primeObject.end());
Alpana Kumari65b83602020-09-01 00:24:56 -05001099
SunnySrivastava19849094d4f2020-08-05 09:32:29 -05001100 // if system VPD has been restored at standby, update the EEPROM
1101 for (const auto& item : updatedEeproms)
1102 {
1103 updateHardware(get<0>(item), get<1>(item), get<2>(item),
1104 get<3>(item));
1105 }
Alpana Kumarif05effd2021-04-07 07:32:53 -05001106
1107 // set the U-boot environment variable for device-tree
1108 if constexpr (is_same<T, Parsed>::value)
1109 {
1110 const string imKeyword = getIM(vpdMap);
1111 const string hwKeyword = getHW(vpdMap);
1112 string systemType = imKeyword;
1113
1114 // check If system has constraint then append HW version to it.
1115 ifstream sysJson(SYSTEM_JSON);
1116 if (!sysJson)
1117 {
1118 throw((VpdJsonException("Failed to access Json path",
1119 SYSTEM_JSON)));
1120 }
1121
1122 try
1123 {
1124 auto systemJson = json::parse(sysJson);
Santosh Puranikd278df12021-05-10 15:51:42 +05301125 if (systemJson["system"].find(imKeyword) !=
1126 systemJson["system"].end())
1127 {
1128 if (systemJson["system"][imKeyword].find("constraint") !=
1129 systemJson["system"][imKeyword].end())
1130 {
1131 systemType += "_" + hwKeyword;
1132 }
1133 }
Alpana Kumarif05effd2021-04-07 07:32:53 -05001134 }
1135 catch (json::parse_error& ex)
1136 {
1137 throw((VpdJsonException("System Json parsing failed",
1138 SYSTEM_JSON)));
1139 }
1140
Alpana Kumarif05effd2021-04-07 07:32:53 -05001141 setDevTreeEnv(systemType);
1142 }
PriyangaRamasamy8e140a12020-04-13 19:24:03 +05301143 }
1144
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301145 // Notify PIM
Sunny Srivastava6c71c9d2021-04-15 04:43:54 -05001146 common::utility::callPIM(move(objects));
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301147}
1148
1149int main(int argc, char** argv)
1150{
1151 int rc = 0;
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001152 json js{};
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001153 Binary vpdVector{};
1154 string file{};
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001155 // map to hold additional data in case of logging pel
1156 PelAdditionalData additionalData{};
1157
1158 // this is needed to hold base fru inventory path in case there is ECC or
1159 // vpd exception while parsing the file
1160 std::string baseFruInventoryPath = {};
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301161
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001162 // severity for PEL
1163 PelSeverity pelSeverity = PelSeverity::WARNING;
1164
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301165 try
1166 {
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301167 App app{"ibm-read-vpd - App to read IPZ format VPD, parse it and store "
1168 "in DBUS"};
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301169
1170 app.add_option("-f, --file", file, "File containing VPD (IPZ/KEYWORD)")
Alpana Kumari2f793042020-08-18 05:51:03 -05001171 ->required();
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301172
1173 CLI11_PARSE(app, argc, argv);
1174
Santosh Puranik12e24ff2021-05-11 19:33:50 +05301175 cout << "Parser launched with file: " << file << "\n";
1176
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001177 // PEL severity should be ERROR in case of any system VPD failure
1178 if (file == systemVpdFilePath)
1179 {
1180 pelSeverity = PelSeverity::ERROR;
1181 }
1182
Santosh Puranik0246a4d2020-11-04 16:57:39 +05301183 auto jsonToParse = INVENTORY_JSON_DEFAULT;
1184
1185 // If the symlink exists, it means it has been setup for us, switch the
1186 // path
1187 if (fs::exists(INVENTORY_JSON_SYM_LINK))
1188 {
1189 jsonToParse = INVENTORY_JSON_SYM_LINK;
1190 }
1191
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301192 // Make sure that the file path we get is for a supported EEPROM
Santosh Puranik0246a4d2020-11-04 16:57:39 +05301193 ifstream inventoryJson(jsonToParse);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001194 if (!inventoryJson)
1195 {
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001196 throw(VpdJsonException("Failed to access Json path", jsonToParse));
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001197 }
1198
1199 try
1200 {
1201 js = json::parse(inventoryJson);
1202 }
1203 catch (json::parse_error& ex)
1204 {
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001205 throw(VpdJsonException("Json parsing failed", jsonToParse));
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001206 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301207
Santosh Puranik12e24ff2021-05-11 19:33:50 +05301208 // Do we have the mandatory "frus" section?
1209 if (js.find("frus") == js.end())
1210 {
1211 throw(VpdJsonException("FRUs section not found in JSON",
1212 jsonToParse));
1213 }
1214
PriyangaRamasamy647868e2020-09-08 17:03:19 +05301215 // Check if it's a udev path - patterned as(/ahb/ahb:apb/ahb:apb:bus@)
1216 if (file.find("/ahb:apb") != string::npos)
1217 {
1218 // Translate udev path to a generic /sys/bus/.. file path.
1219 udevToGenericPath(file);
Santosh Puranik12e24ff2021-05-11 19:33:50 +05301220 cout << "Path after translation: " << file << "\n";
1221
1222 if ((js["frus"].find(file) != js["frus"].end()) &&
Santosh Puranik50f60bf2021-05-26 17:55:06 +05301223 (file == systemVpdFilePath))
PriyangaRamasamy647868e2020-09-08 17:03:19 +05301224 {
1225 return 0;
1226 }
1227 }
1228
1229 if (file.empty())
1230 {
1231 cerr << "The EEPROM path <" << file << "> is not valid.";
1232 return 0;
1233 }
Santosh Puranik12e24ff2021-05-11 19:33:50 +05301234 if (js["frus"].find(file) == js["frus"].end())
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301235 {
Alpana Kumari58e22142020-05-05 00:22:12 -05001236 cout << "Device path not in JSON, ignoring" << endl;
Santosh Puranik88edeb62020-03-02 12:00:09 +05301237 return 0;
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301238 }
1239
Alpana Kumari2f793042020-08-18 05:51:03 -05001240 if (!fs::exists(file))
1241 {
1242 cout << "Device path: " << file
1243 << " does not exist. Spurious udev event? Exiting." << endl;
1244 return 0;
1245 }
1246
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001247 baseFruInventoryPath = js["frus"][file][0]["inventoryPath"];
Santosh Puranik85893752020-11-10 21:31:43 +05301248 // Check if we can read the VPD file based on the power state
1249 if (js["frus"][file].at(0).value("powerOffOnly", false))
1250 {
1251 if ("xyz.openbmc_project.State.Chassis.PowerState.On" ==
1252 getPowerState())
1253 {
1254 cout << "This VPD cannot be read when power is ON" << endl;
1255 return 0;
1256 }
1257 }
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001258
Alpana Kumari2f793042020-08-18 05:51:03 -05001259 try
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301260 {
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001261 vpdVector = getVpdDataInVector(js, file);
PriyangaRamasamy33c61c22021-04-06 11:15:57 -05001262 ParserInterface* parser = ParserFactory::getParser(vpdVector);
Alpana Kumari2f793042020-08-18 05:51:03 -05001263 variant<KeywordVpdMap, Store> parseResult;
1264 parseResult = parser->parse();
SunnySrivastava19849a195542020-09-07 06:04:50 -05001265
Alpana Kumari2f793042020-08-18 05:51:03 -05001266 if (auto pVal = get_if<Store>(&parseResult))
1267 {
1268 populateDbus(pVal->getVpdMap(), js, file);
1269 }
1270 else if (auto pVal = get_if<KeywordVpdMap>(&parseResult))
1271 {
1272 populateDbus(*pVal, js, file);
1273 }
1274
1275 // release the parser object
1276 ParserFactory::freeParser(parser);
1277 }
1278 catch (exception& e)
1279 {
1280 postFailAction(js, file);
PriyangaRamasamya504c3e2020-12-06 12:14:52 -06001281 throw;
Alpana Kumari2f793042020-08-18 05:51:03 -05001282 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301283 }
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001284 catch (const VpdJsonException& ex)
1285 {
1286 additionalData.emplace("JSON_PATH", ex.getJsonPath());
1287 additionalData.emplace("DESCRIPTION", ex.what());
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001288 createPEL(additionalData, pelSeverity, errIntfForJsonFailure);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001289
1290 cerr << ex.what() << "\n";
1291 rc = -1;
1292 }
1293 catch (const VpdEccException& ex)
1294 {
1295 additionalData.emplace("DESCRIPTION", "ECC check failed");
1296 additionalData.emplace("CALLOUT_INVENTORY_PATH",
1297 INVENTORY_PATH + baseFruInventoryPath);
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001298 createPEL(additionalData, pelSeverity, errIntfForEccCheckFail);
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001299 dumpBadVpd(file, vpdVector);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001300 cerr << ex.what() << "\n";
1301 rc = -1;
1302 }
1303 catch (const VpdDataException& ex)
1304 {
1305 additionalData.emplace("DESCRIPTION", "Invalid VPD data");
1306 additionalData.emplace("CALLOUT_INVENTORY_PATH",
1307 INVENTORY_PATH + baseFruInventoryPath);
Sunny Srivastava0746eee2021-03-22 13:36:54 -05001308 createPEL(additionalData, pelSeverity, errIntfForInvalidVPD);
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001309 dumpBadVpd(file, vpdVector);
SunnySrivastava1984a20be8e2020-08-26 02:00:50 -05001310 cerr << ex.what() << "\n";
1311 rc = -1;
1312 }
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301313 catch (exception& e)
1314 {
PriyangaRamasamyc2fe40f2021-03-02 06:27:33 -06001315 dumpBadVpd(file, vpdVector);
PriyangaRamasamyabb87ed2019-11-19 17:25:35 +05301316 cerr << e.what() << "\n";
1317 rc = -1;
1318 }
1319
1320 return rc;
Alpana Kumari3ab26a72021-04-05 19:09:19 +00001321}