blob: 978f2b14e056a2882b06196fada924d0c1c47649 [file] [log] [blame]
Patrick Venture02ba8842018-10-20 13:37:54 -07001#include "writefrudata.hpp"
2
Patrick Venture5c2bd5e2018-10-20 19:45:48 -07003#include "fru_area.hpp"
Patrick Venturec9508db2018-10-16 17:18:43 -07004#include "frup.hpp"
5#include "types.hpp"
6
Patrick Venturec9508db2018-10-16 17:18:43 -07007#include <host-ipmid/ipmid-api.h>
Vishwa4be4b7a2015-10-31 22:55:50 -05008#include <systemd/sd-bus.h>
Chris Austenb45c4cb2015-11-01 06:34:56 -06009#include <unistd.h>
Patrick Venturec9508db2018-10-16 17:18:43 -070010
11#include <algorithm>
Patrick Venture5c787212018-10-17 13:48:23 -070012#include <cstdio>
13#include <cstring>
Patrick Venturec9508db2018-10-16 17:18:43 -070014#include <exception>
15#include <fstream>
vishwac93d6d42015-12-16 11:55:16 -060016#include <iostream>
Patrick Ventureb390c0e2018-10-20 13:36:48 -070017#include <map>
vishwac93d6d42015-12-16 11:55:16 -060018#include <memory>
Patrick Venture5739ac32018-10-16 19:17:41 -070019#include <phosphor-logging/log.hpp>
Patrick Venture71918492018-10-20 19:40:13 -070020#include <sdbusplus/bus.hpp>
Patrick Venturec9508db2018-10-16 17:18:43 -070021#include <sstream>
22#include <vector>
Vishwa4be4b7a2015-10-31 22:55:50 -050023
Deepak Kodihalli788bd1f2017-02-20 01:21:59 -060024using namespace ipmi::vpd;
Patrick Venture5739ac32018-10-16 19:17:41 -070025using namespace phosphor::logging;
Deepak Kodihalli788bd1f2017-02-20 01:21:59 -060026
Ratan Guptacb0d4e52016-12-22 19:05:57 +053027extern const FruMap frus;
Deepak Kodihalli788bd1f2017-02-20 01:21:59 -060028extern const std::map<Path, InterfaceMap> extras;
Ratan Guptacb0d4e52016-12-22 19:05:57 +053029
Patrick Venture19bea9a2018-10-20 19:54:27 -070030using FruAreaVector = std::vector<std::unique_ptr<IPMIFruArea>>;
31
Patrick Venture234b7352018-10-20 09:37:09 -070032namespace
33{
34
35//------------------------------------------------------------
36// Cleanup routine
37// Must always be called as last reference to fru_fp.
38//------------------------------------------------------------
Patrick Venture19bea9a2018-10-20 19:54:27 -070039int cleanupError(FILE* fru_fp, FruAreaVector& fru_area_vec)
Patrick Venture234b7352018-10-20 09:37:09 -070040{
41 if (fru_fp != NULL)
42 {
43 std::fclose(fru_fp);
44 }
45
46 if (!(fru_area_vec.empty()))
47 {
48 fru_area_vec.clear();
49 }
50
51 return -1;
52}
53
Patrick Venturede8ea562018-10-20 09:44:19 -070054//------------------------------------------------------------------------
55// Gets the value of the key from the fru dictionary of the given section.
56// FRU dictionary is parsed fru data for all the sections.
57//------------------------------------------------------------------------
58std::string getFRUValue(const std::string& section, const std::string& key,
59 const std::string& delimiter, IPMIFruInfo& fruData)
60{
61
62 auto minIndexValue = 0;
63 auto maxIndexValue = 0;
64 std::string fruValue = "";
65
66 if (section == "Board")
67 {
68 minIndexValue = OPENBMC_VPD_KEY_BOARD_MFG_DATE;
69 maxIndexValue = OPENBMC_VPD_KEY_BOARD_MAX;
70 }
71 else if (section == "Product")
72 {
73 minIndexValue = OPENBMC_VPD_KEY_PRODUCT_MFR;
74 maxIndexValue = OPENBMC_VPD_KEY_PRODUCT_MAX;
75 }
76 else if (section == "Chassis")
77 {
78 minIndexValue = OPENBMC_VPD_KEY_CHASSIS_TYPE;
79 maxIndexValue = OPENBMC_VPD_KEY_CHASSIS_MAX;
80 }
81
82 auto first = fruData.cbegin() + minIndexValue;
83 auto last = first + (maxIndexValue - minIndexValue) + 1;
84
85 auto itr =
86 std::find_if(first, last, [&key](auto& e) { return key == e.first; });
87
88 if (itr != last)
89 {
90 fruValue = itr->second;
91 }
92
93 // if the key is custom property then the value could be in two formats.
94 // 1) custom field 2 = "value".
95 // 2) custom field 2 = "key:value".
96 // if delimiter length = 0 i.e custom field 2 = "value"
97
98 constexpr auto customProp = "Custom Field";
99 if (key.find(customProp) != std::string::npos)
100 {
101 if (delimiter.length() > 0)
102 {
103 size_t delimiterpos = fruValue.find(delimiter);
104 if (delimiterpos != std::string::npos)
105 fruValue = fruValue.substr(delimiterpos + 1);
106 }
107 }
108 return fruValue;
109}
110
Patrick Venture17baa272018-10-20 09:48:08 -0700111// Get the inventory service from the mapper.
112auto getService(sdbusplus::bus::bus& bus, const std::string& intf,
113 const std::string& path)
114{
115 auto mapperCall =
116 bus.new_method_call("xyz.openbmc_project.ObjectMapper",
117 "/xyz/openbmc_project/object_mapper",
118 "xyz.openbmc_project.ObjectMapper", "GetObject");
119
120 mapperCall.append(path);
121 mapperCall.append(std::vector<std::string>({intf}));
122 std::map<std::string, std::vector<std::string>> mapperResponse;
123
124 try
125 {
126 auto mapperResponseMsg = bus.call(mapperCall);
127 mapperResponseMsg.read(mapperResponse);
128 }
129 catch (const sdbusplus::exception::SdBusError& ex)
130 {
131 log<level::ERR>("Exception from sdbus call",
132 entry("WHAT=%s", ex.what()));
133 throw;
134 }
135
136 if (mapperResponse.begin() == mapperResponse.end())
137 {
138 throw std::runtime_error("ERROR in reading the mapper response");
139 }
140
141 return mapperResponse.begin()->first;
142}
143
Patrick Venture44a957d2018-10-20 09:41:29 -0700144// Takes FRU data, invokes Parser for each fru record area and updates
145// Inventory
146//------------------------------------------------------------------------
Patrick Venture19bea9a2018-10-20 19:54:27 -0700147int updateInventory(FruAreaVector& area_vec, sd_bus* bus_sd)
Patrick Venture44a957d2018-10-20 09:41:29 -0700148{
149 // Generic error reporter
150 int rc = 0;
151 uint8_t fruid = 0;
152 IPMIFruInfo fruData;
153
154 // For each FRU area, extract the needed data , get it parsed and update
155 // the Inventory.
156 for (const auto& fruArea : area_vec)
157 {
158 fruid = fruArea->get_fruid();
159 // Fill the container with information
160 rc = parse_fru_area((fruArea)->get_type(), (void*)(fruArea)->get_data(),
161 (fruArea)->get_len(), fruData);
162 if (rc < 0)
163 {
164 log<level::ERR>("Error parsing FRU records");
165 return rc;
166 }
167 } // END walking the vector of areas and updating
168
169 // For each Fru we have the list of instances which needs to be updated.
170 // Each instance object implements certain interfaces.
171 // Each Interface is having Dbus properties.
172 // Each Dbus Property would be having metaData(eg section,VpdPropertyName).
173
174 // Here we are just printing the object,interface and the properties.
175 // which needs to be called with the new inventory manager implementation.
176 sdbusplus::bus::bus bus{bus_sd};
177 using namespace std::string_literals;
178 static const auto intf = "xyz.openbmc_project.Inventory.Manager"s;
179 static const auto path = "/xyz/openbmc_project/inventory"s;
180 std::string service;
181 try
182 {
183 service = getService(bus, intf, path);
184 }
185 catch (const std::exception& e)
186 {
187 std::cerr << e.what() << "\n";
188 return -1;
189 }
190
191 auto iter = frus.find(fruid);
192 if (iter == frus.end())
193 {
194 log<level::ERR>("Unable to get the fru info",
195 entry("FRU=%d", static_cast<int>(fruid)));
196 return -1;
197 }
198
199 auto& instanceList = iter->second;
200 if (instanceList.size() <= 0)
201 {
202 log<level::DEBUG>("Object list empty for this FRU",
203 entry("FRU=%d", static_cast<int>(fruid)));
204 }
205
206 ObjectMap objects;
207 for (auto& instance : instanceList)
208 {
209 InterfaceMap interfaces;
210 const auto& extrasIter = extras.find(instance.path);
211
212 for (auto& interfaceList : instance.interfaces)
213 {
214 PropertyMap props; // store all the properties
215 for (auto& properties : interfaceList.second)
216 {
217 std::string value;
218 decltype(auto) pdata = properties.second;
219
220 if (!pdata.section.empty() && !pdata.property.empty())
221 {
222 value = getFRUValue(pdata.section, pdata.property,
223 pdata.delimiter, fruData);
224 }
225 props.emplace(std::move(properties.first), std::move(value));
226 }
227 // Check and update extra properties
228 if (extras.end() != extrasIter)
229 {
230 const auto& propsIter =
231 (extrasIter->second).find(interfaceList.first);
232 if ((extrasIter->second).end() != propsIter)
233 {
234 for (const auto& map : propsIter->second)
235 {
236 props.emplace(map.first, map.second);
237 }
238 }
239 }
240 interfaces.emplace(std::move(interfaceList.first),
241 std::move(props));
242 }
243
244 // Call the inventory manager
Patrick Venture9a528f22018-10-20 13:31:28 -0700245 sdbusplus::message::object_path objectPath = instance.path;
Patrick Venture44a957d2018-10-20 09:41:29 -0700246 // Check and update extra properties
247 if (extras.end() != extrasIter)
248 {
249 for (const auto& entry : extrasIter->second)
250 {
251 if (interfaces.end() == interfaces.find(entry.first))
252 {
253 interfaces.emplace(entry.first, entry.second);
254 }
255 }
256 }
Patrick Venture9a528f22018-10-20 13:31:28 -0700257 objects.emplace(objectPath, interfaces);
Patrick Venture44a957d2018-10-20 09:41:29 -0700258 }
259
260 auto pimMsg = bus.new_method_call(service.c_str(), path.c_str(),
261 intf.c_str(), "Notify");
262 pimMsg.append(std::move(objects));
263
264 try
265 {
266 auto inventoryMgrResponseMsg = bus.call(pimMsg);
267 }
268 catch (const sdbusplus::exception::SdBusError& ex)
269 {
270 log<level::ERR>("Error in notify call", entry("WHAT=%s", ex.what()));
271 return -1;
272 }
273
274 return rc;
275}
276
Patrick Venture234b7352018-10-20 09:37:09 -0700277} // namespace
278
Vishwa4be4b7a2015-10-31 22:55:50 -0500279//------------------------------------------------
vishwaf3ca3522015-12-02 10:35:13 -0600280// Takes the pointer to stream of bytes and length
vishwac93d6d42015-12-16 11:55:16 -0600281// and returns the 8 bit checksum
282// This algo is per IPMI V2.0 spec
Vishwa4be4b7a2015-10-31 22:55:50 -0500283//-------------------------------------------------
Patrick Venturec9508db2018-10-16 17:18:43 -0700284unsigned char calculate_crc(const unsigned char* data, size_t len)
Vishwa4be4b7a2015-10-31 22:55:50 -0500285{
286 char crc = 0;
vishwac93d6d42015-12-16 11:55:16 -0600287 size_t byte = 0;
Vishwa4be4b7a2015-10-31 22:55:50 -0500288
Patrick Venturec9508db2018-10-16 17:18:43 -0700289 for (byte = 0; byte < len; byte++)
Vishwa4be4b7a2015-10-31 22:55:50 -0500290 {
291 crc += *data++;
292 }
vishwaf3ca3522015-12-02 10:35:13 -0600293
Patrick Venturec9508db2018-10-16 17:18:43 -0700294 return (-crc);
Vishwa4be4b7a2015-10-31 22:55:50 -0500295}
296
297//---------------------------------------------------------------------
298// Accepts a fru area offset in commom hdr and tells which area it is.
299//---------------------------------------------------------------------
vishwac93d6d42015-12-16 11:55:16 -0600300ipmi_fru_area_type get_fru_area_type(uint8_t area_offset)
Vishwa4be4b7a2015-10-31 22:55:50 -0500301{
302 ipmi_fru_area_type type = IPMI_FRU_AREA_TYPE_MAX;
303
Patrick Venturec9508db2018-10-16 17:18:43 -0700304 switch (area_offset)
Vishwa4be4b7a2015-10-31 22:55:50 -0500305 {
306 case IPMI_FRU_INTERNAL_OFFSET:
307 type = IPMI_FRU_AREA_INTERNAL_USE;
308 break;
309
310 case IPMI_FRU_CHASSIS_OFFSET:
311 type = IPMI_FRU_AREA_CHASSIS_INFO;
312 break;
313
314 case IPMI_FRU_BOARD_OFFSET:
315 type = IPMI_FRU_AREA_BOARD_INFO;
316 break;
317
318 case IPMI_FRU_PRODUCT_OFFSET:
319 type = IPMI_FRU_AREA_PRODUCT_INFO;
320 break;
321
322 case IPMI_FRU_MULTI_OFFSET:
323 type = IPMI_FRU_AREA_MULTI_RECORD;
324 break;
325
326 default:
327 type = IPMI_FRU_AREA_TYPE_MAX;
328 }
329
330 return type;
331}
332
vishwac93d6d42015-12-16 11:55:16 -0600333///-----------------------------------------------
334// Validates the data for crc and mandatory fields
335///-----------------------------------------------
Patrick Venturec9508db2018-10-16 17:18:43 -0700336int verify_fru_data(const uint8_t* data, const size_t len)
vishwac93d6d42015-12-16 11:55:16 -0600337{
338 uint8_t checksum = 0;
339 int rc = -1;
340
341 // Validate for first byte to always have a value of [1]
Patrick Venturec9508db2018-10-16 17:18:43 -0700342 if (data[0] != IPMI_FRU_HDR_BYTE_ZERO)
vishwac93d6d42015-12-16 11:55:16 -0600343 {
Patrick Venture5c787212018-10-17 13:48:23 -0700344 log<level::ERR>("Invalid entry in byte-0",
345 entry("ENTRY=0x%X", static_cast<uint32_t>(data[0])));
vishwac93d6d42015-12-16 11:55:16 -0600346 return rc;
347 }
348#ifdef __IPMI_DEBUG__
349 else
350 {
Patrick Venture5c787212018-10-17 13:48:23 -0700351 log<level::DEBUG>("Validated in entry_1 of fru_data",
352 entry("ENTRY=0x%X", static_cast<uint32_t>(data[0])));
vishwac93d6d42015-12-16 11:55:16 -0600353 }
354#endif
355
356 // See if the calculated CRC matches with the embedded one.
357 // CRC to be calculated on all except the last one that is CRC itself.
358 checksum = calculate_crc(data, len - 1);
Patrick Venturec9508db2018-10-16 17:18:43 -0700359 if (checksum != data[len - 1])
vishwac93d6d42015-12-16 11:55:16 -0600360 {
361#ifdef __IPMI_DEBUG__
Patrick Venture5c787212018-10-17 13:48:23 -0700362 log<level::ERR>(
363 "Checksum mismatch",
364 entry("Calculated=0x%X", static_cast<uint32_t>(checksum)),
365 entry("Embedded=0x%X", static_cast<uint32_t>(data[len])));
vishwac93d6d42015-12-16 11:55:16 -0600366#endif
367 return rc;
368 }
369#ifdef __IPMI_DEBUG__
370 else
371 {
Patrick Venture5c787212018-10-17 13:48:23 -0700372 log<level::DEBUG>("Checksum matches");
vishwac93d6d42015-12-16 11:55:16 -0600373 }
374#endif
375
376 return EXIT_SUCCESS;
377}
378
vishwac93d6d42015-12-16 11:55:16 -0600379///----------------------------------------------------
380// Checks if a particular fru area is populated or not
381///----------------------------------------------------
Patrick Venture9eb82cf2018-10-20 19:36:01 -0700382bool remove_invalid_area(const std::unique_ptr<IPMIFruArea>& fru_area)
Vishwa4be4b7a2015-10-31 22:55:50 -0500383{
Deepak Kodihalli89ededd2017-02-11 01:59:32 -0600384 // Filter the ones that are empty
Patrick Venturec9508db2018-10-16 17:18:43 -0700385 if (!(fru_area->get_len()))
vishwac93d6d42015-12-16 11:55:16 -0600386 {
387 return true;
388 }
389 return false;
390}
Vishwa4be4b7a2015-10-31 22:55:50 -0500391
vishwac93d6d42015-12-16 11:55:16 -0600392///----------------------------------------------------------------------------------
393// Populates various FRU areas
394// @prereq : This must be called only after validating common header.
395///----------------------------------------------------------------------------------
Patrick Venturec9508db2018-10-16 17:18:43 -0700396int ipmi_populate_fru_areas(uint8_t* fru_data, const size_t data_len,
Patrick Venture19bea9a2018-10-20 19:54:27 -0700397 FruAreaVector& fru_area_vec)
vishwac93d6d42015-12-16 11:55:16 -0600398{
vishwac93d6d42015-12-16 11:55:16 -0600399 int rc = -1;
Vishwa4be4b7a2015-10-31 22:55:50 -0500400
vishwac93d6d42015-12-16 11:55:16 -0600401 // Now walk the common header and see if the file size has atleast the last
402 // offset mentioned by the common_hdr. If the file size is less than the
403 // offset of any if the fru areas mentioned in the common header, then we do
404 // not have a complete file.
Patrick Venturec9508db2018-10-16 17:18:43 -0700405 for (uint8_t fru_entry = IPMI_FRU_INTERNAL_OFFSET;
406 fru_entry < (sizeof(struct common_header) - 2); fru_entry++)
vishwac93d6d42015-12-16 11:55:16 -0600407 {
Yi Li75c2d462016-04-11 16:57:46 +0800408 rc = -1;
vishwac93d6d42015-12-16 11:55:16 -0600409 // Actual offset in the payload is the offset mentioned in common header
Gunnar Millsc19b8132018-06-14 08:56:17 -0500410 // multiplied by 8. Common header is always the first 8 bytes.
Patrick Venture50ddfe52018-10-16 17:16:32 -0700411 size_t area_offset = fru_data[fru_entry] * IPMI_EIGHT_BYTES;
Patrick Venturec9508db2018-10-16 17:18:43 -0700412 if (area_offset && (data_len < (area_offset + 2)))
vishwac93d6d42015-12-16 11:55:16 -0600413 {
414 // Our file size is less than what it needs to be. +2 because we are
415 // using area len that is at 2 byte off area_offset
Patrick Venture5c787212018-10-17 13:48:23 -0700416 log<level::ERR>("fru file is incomplete",
417 entry("SIZE=%d", data_len));
vishwac93d6d42015-12-16 11:55:16 -0600418 return rc;
419 }
Patrick Venturec9508db2018-10-16 17:18:43 -0700420 else if (area_offset)
vishwac93d6d42015-12-16 11:55:16 -0600421 {
422 // Read 2 bytes to know the actual size of area.
423 uint8_t area_hdr[2] = {0};
Patrick Venture5c787212018-10-17 13:48:23 -0700424 std::memcpy(area_hdr, &((uint8_t*)fru_data)[area_offset],
425 sizeof(area_hdr));
Vishwa4be4b7a2015-10-31 22:55:50 -0500426
vishwac93d6d42015-12-16 11:55:16 -0600427 // Size of this area will be the 2nd byte in the fru area header.
Patrick Venturec9508db2018-10-16 17:18:43 -0700428 size_t area_len = area_hdr[1] * IPMI_EIGHT_BYTES;
vishwac93d6d42015-12-16 11:55:16 -0600429 uint8_t area_data[area_len] = {0};
Vishwa4be4b7a2015-10-31 22:55:50 -0500430
Patrick Venture5c787212018-10-17 13:48:23 -0700431 log<level::DEBUG>("Fru Data", entry("SIZE=%d", data_len),
432 entry("AREA OFFSET=%d", area_offset),
433 entry("AREA_SIZE=%d", area_len));
Vishwa4be4b7a2015-10-31 22:55:50 -0500434
vishwac93d6d42015-12-16 11:55:16 -0600435 // See if we really have that much buffer. We have area offset amd
436 // from there, the actual len.
Patrick Venturec9508db2018-10-16 17:18:43 -0700437 if (data_len < (area_len + area_offset))
vishwac93d6d42015-12-16 11:55:16 -0600438 {
Patrick Venture5c787212018-10-17 13:48:23 -0700439 log<level::ERR>("Incomplete Fru file",
440 entry("SIZE=%d", data_len));
vishwac93d6d42015-12-16 11:55:16 -0600441 return rc;
442 }
443
444 // Save off the data.
Patrick Venture5c787212018-10-17 13:48:23 -0700445 std::memcpy(area_data, &((uint8_t*)fru_data)[area_offset],
446 area_len);
vishwac93d6d42015-12-16 11:55:16 -0600447
448 // Validate the crc
449 rc = verify_fru_data(area_data, area_len);
Patrick Venturec9508db2018-10-16 17:18:43 -0700450 if (rc < 0)
vishwac93d6d42015-12-16 11:55:16 -0600451 {
Patrick Venture5c787212018-10-17 13:48:23 -0700452 log<level::ERR>("Err validating fru area",
453 entry("OFFSET=%d", area_offset));
vishwac93d6d42015-12-16 11:55:16 -0600454 return rc;
455 }
456 else
457 {
Patrick Venture5c787212018-10-17 13:48:23 -0700458 log<level::DEBUG>("Successfully verified area checksum.",
459 entry("OFFSET=%d", area_offset));
vishwac93d6d42015-12-16 11:55:16 -0600460 }
461
462 // We already have a vector that is passed to us containing all
463 // of the fields populated. Update the data portion now.
Patrick Venturec9508db2018-10-16 17:18:43 -0700464 for (auto& iter : fru_area_vec)
vishwac93d6d42015-12-16 11:55:16 -0600465 {
Patrick Venturec9508db2018-10-16 17:18:43 -0700466 if ((iter)->get_type() == get_fru_area_type(fru_entry))
vishwac93d6d42015-12-16 11:55:16 -0600467 {
468 (iter)->set_data(area_data, area_len);
469 }
470 }
471 } // If we have fru data present
Patrick Venturec9508db2018-10-16 17:18:43 -0700472 } // Walk common_hdr
vishwac93d6d42015-12-16 11:55:16 -0600473
474 // Not all the fields will be populated in a fru data. Mostly all cases will
475 // not have more than 2 or 3.
476 fru_area_vec.erase(std::remove_if(fru_area_vec.begin(), fru_area_vec.end(),
Patrick Venturec9508db2018-10-16 17:18:43 -0700477 remove_invalid_area),
478 fru_area_vec.end());
vishwac93d6d42015-12-16 11:55:16 -0600479
480 return EXIT_SUCCESS;
481}
482
483///---------------------------------------------------------
484// Validates the fru data per ipmi common header constructs.
485// Returns with updated common_hdr and also file_size
486//----------------------------------------------------------
Patrick Venturec9508db2018-10-16 17:18:43 -0700487int ipmi_validate_common_hdr(const uint8_t* fru_data, const size_t data_len)
vishwac93d6d42015-12-16 11:55:16 -0600488{
489 int rc = -1;
Vishwa4be4b7a2015-10-31 22:55:50 -0500490
491 uint8_t common_hdr[sizeof(struct common_header)] = {0};
Patrick Venturec9508db2018-10-16 17:18:43 -0700492 if (data_len >= sizeof(common_hdr))
Vishwa4be4b7a2015-10-31 22:55:50 -0500493 {
Patrick Venture5c787212018-10-17 13:48:23 -0700494 std::memcpy(common_hdr, fru_data, sizeof(common_hdr));
Vishwa4be4b7a2015-10-31 22:55:50 -0500495 }
496 else
497 {
Patrick Venture5c787212018-10-17 13:48:23 -0700498 log<level::ERR>("Incomplete fru data file", entry("SIZE=%d", data_len));
vishwac93d6d42015-12-16 11:55:16 -0600499 return rc;
Vishwa4be4b7a2015-10-31 22:55:50 -0500500 }
501
vishwac93d6d42015-12-16 11:55:16 -0600502 // Verify the crc and size
503 rc = verify_fru_data(common_hdr, sizeof(common_hdr));
Patrick Venturec9508db2018-10-16 17:18:43 -0700504 if (rc < 0)
Vishwa4be4b7a2015-10-31 22:55:50 -0500505 {
Patrick Venture5c787212018-10-17 13:48:23 -0700506 log<level::ERR>("Failed to validate common header");
vishwac93d6d42015-12-16 11:55:16 -0600507 return rc;
Vishwa4be4b7a2015-10-31 22:55:50 -0500508 }
509
vishwac93d6d42015-12-16 11:55:16 -0600510 return EXIT_SUCCESS;
511}
Vishwa4be4b7a2015-10-31 22:55:50 -0500512
Vishwa4be4b7a2015-10-31 22:55:50 -0500513///-----------------------------------------------------
514// Accepts the filename and validates per IPMI FRU spec
515//----------------------------------------------------
Patrick Venture98072dc2018-10-20 09:31:35 -0700516int validateFRUArea(const uint8_t fruid, const char* fru_file_name,
517 sd_bus* bus_type, const bool bmc_fru)
Vishwa4be4b7a2015-10-31 22:55:50 -0500518{
vishwac93d6d42015-12-16 11:55:16 -0600519 size_t data_len = 0;
520 size_t bytes_read = 0;
521 int rc = -1;
Vishwa4be4b7a2015-10-31 22:55:50 -0500522
vishwac93d6d42015-12-16 11:55:16 -0600523 // Vector that holds individual IPMI FRU AREAs. Although MULTI and INTERNAL
524 // are not used, keeping it here for completeness.
Patrick Venture19bea9a2018-10-20 19:54:27 -0700525 FruAreaVector fru_area_vec;
Yi Li75c2d462016-04-11 16:57:46 +0800526
Patrick Venturec9508db2018-10-16 17:18:43 -0700527 for (uint8_t fru_entry = IPMI_FRU_INTERNAL_OFFSET;
528 fru_entry < (sizeof(struct common_header) - 2); fru_entry++)
vishwac93d6d42015-12-16 11:55:16 -0600529 {
530 // Create an object and push onto a vector.
Patrick Venture9eb82cf2018-10-20 19:36:01 -0700531 std::unique_ptr<IPMIFruArea> fru_area = std::make_unique<IPMIFruArea>(
Patrick Ventured9af7b42018-10-20 19:23:36 -0700532 fruid, get_fru_area_type(fru_entry), bmc_fru);
vishwac93d6d42015-12-16 11:55:16 -0600533
534 // Physically being present
vishwa2f5a3cf2016-05-30 02:25:21 -0500535 bool present = access(fru_file_name, F_OK) == 0;
vishwac93d6d42015-12-16 11:55:16 -0600536 fru_area->set_present(present);
537
vishwac93d6d42015-12-16 11:55:16 -0600538 fru_area_vec.emplace_back(std::move(fru_area));
539 }
540
Patrick Venture5c787212018-10-17 13:48:23 -0700541 FILE* fru_fp = std::fopen(fru_file_name, "rb");
Patrick Venturec9508db2018-10-16 17:18:43 -0700542 if (fru_fp == NULL)
Vishwa4be4b7a2015-10-31 22:55:50 -0500543 {
Patrick Venture5c787212018-10-17 13:48:23 -0700544 log<level::ERR>("Unable to open fru file",
545 entry("FILE=%s", fru_file_name),
546 entry("ERRNO=%s", std::strerror(errno)));
Patrick Venture234b7352018-10-20 09:37:09 -0700547 return cleanupError(fru_fp, fru_area_vec);
Vishwa4be4b7a2015-10-31 22:55:50 -0500548 }
549
vishwac93d6d42015-12-16 11:55:16 -0600550 // Get the size of the file to see if it meets minimum requirement
Patrick Venture5c787212018-10-17 13:48:23 -0700551 if (std::fseek(fru_fp, 0, SEEK_END))
Vishwa4be4b7a2015-10-31 22:55:50 -0500552 {
Patrick Venture5c787212018-10-17 13:48:23 -0700553 log<level::ERR>("Unable to seek fru file",
554 entry("FILE=%s", fru_file_name),
555 entry("ERRNO=%s", std::strerror(errno)));
Patrick Venture234b7352018-10-20 09:37:09 -0700556 return cleanupError(fru_fp, fru_area_vec);
Vishwa4be4b7a2015-10-31 22:55:50 -0500557 }
558
vishwac93d6d42015-12-16 11:55:16 -0600559 // Allocate a buffer to hold entire file content
Patrick Venture5c787212018-10-17 13:48:23 -0700560 data_len = std::ftell(fru_fp);
vishwac93d6d42015-12-16 11:55:16 -0600561 uint8_t fru_data[data_len] = {0};
Vishwa4be4b7a2015-10-31 22:55:50 -0500562
Patrick Venture5c787212018-10-17 13:48:23 -0700563 std::rewind(fru_fp);
564 bytes_read = std::fread(fru_data, data_len, 1, fru_fp);
Patrick Venturec9508db2018-10-16 17:18:43 -0700565 if (bytes_read != 1)
Vishwa4be4b7a2015-10-31 22:55:50 -0500566 {
Patrick Venture5c787212018-10-17 13:48:23 -0700567 log<level::ERR>("Failed reading fru data.",
568 entry("BYTESREAD=%d", bytes_read),
569 entry("ERRNO=%s", std::strerror(errno)));
Patrick Venture234b7352018-10-20 09:37:09 -0700570 return cleanupError(fru_fp, fru_area_vec);
Vishwa4be4b7a2015-10-31 22:55:50 -0500571 }
Vishwa4be4b7a2015-10-31 22:55:50 -0500572
vishwac93d6d42015-12-16 11:55:16 -0600573 // We are done reading.
Patrick Venture5c787212018-10-17 13:48:23 -0700574 std::fclose(fru_fp);
vishwac93d6d42015-12-16 11:55:16 -0600575 fru_fp = NULL;
576
577 rc = ipmi_validate_common_hdr(fru_data, data_len);
Patrick Venturec9508db2018-10-16 17:18:43 -0700578 if (rc < 0)
Vishwa4be4b7a2015-10-31 22:55:50 -0500579 {
Patrick Venture234b7352018-10-20 09:37:09 -0700580 return cleanupError(fru_fp, fru_area_vec);
vishwac93d6d42015-12-16 11:55:16 -0600581 }
582
Patrick Venturec9508db2018-10-16 17:18:43 -0700583 // Now that we validated the common header, populate various fru sections if
584 // we have them here.
vishwac93d6d42015-12-16 11:55:16 -0600585 rc = ipmi_populate_fru_areas(fru_data, data_len, fru_area_vec);
Patrick Venturec9508db2018-10-16 17:18:43 -0700586 if (rc < 0)
vishwac93d6d42015-12-16 11:55:16 -0600587 {
Patrick Venture5c787212018-10-17 13:48:23 -0700588 log<level::ERR>("Populating FRU areas failed", entry("FRU=%d", fruid));
Patrick Venture234b7352018-10-20 09:37:09 -0700589 return cleanupError(fru_fp, fru_area_vec);
Vishwa4be4b7a2015-10-31 22:55:50 -0500590 }
591 else
592 {
Patrick Venture5c787212018-10-17 13:48:23 -0700593 log<level::DEBUG>("Populated FRU areas",
594 entry("FILE=%s", fru_file_name));
Vishwa4be4b7a2015-10-31 22:55:50 -0500595 }
596
vishwac93d6d42015-12-16 11:55:16 -0600597#ifdef __IPMI_DEBUG__
Patrick Venturec9508db2018-10-16 17:18:43 -0700598 for (auto& iter : fru_area_vec)
Vishwa4be4b7a2015-10-31 22:55:50 -0500599 {
Patrick Venture5c787212018-10-17 13:48:23 -0700600 std::printf("FRU ID : [%d]\n", (iter)->get_fruid());
601 std::printf("AREA NAME : [%s]\n", (iter)->get_name());
602 std::printf("TYPE : [%d]\n", (iter)->get_type());
603 std::printf("LEN : [%d]\n", (iter)->get_len());
604 std::printf("BUS NAME : [%s]\n", (iter)->get_bus_name());
605 std::printf("OBJ PATH : [%s]\n", (iter)->get_obj_path());
606 std::printf("INTF NAME :[%s]\n", (iter)->get_intf_name());
Vishwa4be4b7a2015-10-31 22:55:50 -0500607 }
vishwac93d6d42015-12-16 11:55:16 -0600608#endif
609
610 // If the vector is populated with everything, then go ahead and update the
611 // inventory.
Patrick Venturec9508db2018-10-16 17:18:43 -0700612 if (!(fru_area_vec.empty()))
vishwac93d6d42015-12-16 11:55:16 -0600613 {
614
615#ifdef __IPMI_DEBUG__
Patrick Venture5c787212018-10-17 13:48:23 -0700616 std::printf("\n SIZE of vector is : [%d] \n", fru_area_vec.size());
vishwac93d6d42015-12-16 11:55:16 -0600617#endif
Patrick Venture44a957d2018-10-20 09:41:29 -0700618 rc = updateInventory(fru_area_vec, bus_type);
Patrick Venturec9508db2018-10-16 17:18:43 -0700619 if (rc < 0)
vishwac93d6d42015-12-16 11:55:16 -0600620 {
Patrick Venture5c787212018-10-17 13:48:23 -0700621 log<level::ERR>("Error updating inventory.");
vishwac93d6d42015-12-16 11:55:16 -0600622 }
623 }
624
625 // we are done with all that we wanted to do. This will do the job of
626 // calling any destructors too.
627 fru_area_vec.clear();
Vishwa4be4b7a2015-10-31 22:55:50 -0500628
629 return rc;
630}