blob: 8ca7fd5832b28e6ecc1e8b24121104eb156c9620 [file] [log] [blame]
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07001/*
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07002// Copyright (c) 2017-2019 Intel Corporation
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07003//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16
Patrick Ventureca99ef52019-10-20 14:00:50 -070017#include "storagecommands.hpp"
18
19#include "commandutils.hpp"
Peter Foley21a1b5f2023-10-31 17:42:04 -040020#include "fruutils.hpp"
Patrick Ventureca99ef52019-10-20 14:00:50 -070021#include "ipmi_to_redfish_hooks.hpp"
22#include "sdrutils.hpp"
Patrick Venturec2a07d42020-05-30 16:35:03 -070023#include "types.hpp"
Patrick Ventureca99ef52019-10-20 14:00:50 -070024
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070025#include <boost/algorithm/string.hpp>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070026#include <boost/container/flat_map.hpp>
Johnathan Manteyee27fe02024-06-26 07:54:42 -070027#include <boost/process.hpp>
James Feist2a265d52019-04-08 11:16:27 -070028#include <ipmid/api.hpp>
James Feist25690252019-12-23 12:25:49 -080029#include <ipmid/message.hpp>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070030#include <phosphor-logging/log.hpp>
31#include <sdbusplus/message/types.hpp>
32#include <sdbusplus/timer.hpp>
James Feistfcd2d3a2020-05-28 10:38:15 -070033
34#include <filesystem>
Archana Kakanif23fd542021-09-16 05:05:10 +000035#include <fstream>
Johnathan Manteyee27fe02024-06-26 07:54:42 -070036#include <functional>
James Feistfcd2d3a2020-05-28 10:38:15 -070037#include <iostream>
Jason M. Billsc04e2e72018-11-28 15:15:56 -080038#include <stdexcept>
Johnathan Manteyee27fe02024-06-26 07:54:42 -070039#include <string_view>
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070040
Patrick Venture9ce789f2019-10-17 09:09:39 -070041static constexpr bool DEBUG = false;
42
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070043namespace intel_oem::ipmi::sel
44{
45static const std::filesystem::path selLogDir = "/var/log";
46static const std::string selLogFilename = "ipmi_sel";
47
48static int getFileTimestamp(const std::filesystem::path& file)
49{
50 struct stat st;
51
52 if (stat(file.c_str(), &st) >= 0)
53 {
54 return st.st_mtime;
55 }
56 return ::ipmi::sel::invalidTimeStamp;
57}
58
59namespace erase_time
Jason M. Bills7944c302019-03-20 15:24:05 -070060{
61static constexpr const char* selEraseTimestamp = "/var/lib/ipmi/sel_erase_time";
62
63void save()
64{
65 // open the file, creating it if necessary
66 int fd = open(selEraseTimestamp, O_WRONLY | O_CREAT | O_CLOEXEC, 0644);
67 if (fd < 0)
68 {
69 std::cerr << "Failed to open file\n";
70 return;
71 }
72
73 // update the file timestamp to the current time
74 if (futimens(fd, NULL) < 0)
75 {
76 std::cerr << "Failed to update timestamp: "
77 << std::string(strerror(errno));
78 }
79 close(fd);
80}
81
82int get()
83{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070084 return getFileTimestamp(selEraseTimestamp);
Jason M. Bills7944c302019-03-20 15:24:05 -070085}
Jason M. Bills1d4d54d2019-04-23 11:26:11 -070086} // namespace erase_time
87} // namespace intel_oem::ipmi::sel
Jason M. Bills7944c302019-03-20 15:24:05 -070088
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070089namespace ipmi
90{
91
92namespace storage
93{
94
Jason M. Billse2d1aee2018-10-03 15:57:18 -070095constexpr static const size_t maxMessageSize = 64;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -070096constexpr static const size_t maxFruSdrNameSize = 16;
James Feiste4f710d2020-05-20 15:50:30 -070097using ObjectType = boost::container::flat_map<
98 std::string, boost::container::flat_map<std::string, DbusVariant>>;
99using ManagedObjectType =
100 boost::container::flat_map<sdbusplus::message::object_path, ObjectType>;
101using ManagedEntry = std::pair<sdbusplus::message::object_path, ObjectType>;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700102
James Feist3bcba452018-12-20 12:31:03 -0800103constexpr static const char* fruDeviceServiceName =
104 "xyz.openbmc_project.FruDevice";
James Feist25690252019-12-23 12:25:49 -0800105constexpr static const size_t writeTimeoutSeconds = 10;
Anoop S358e7df2020-05-05 16:43:34 +0000106constexpr static const char* chassisTypeRackMount = "23";
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700107
Jason M. Bills4ed6f2c2019-04-02 12:21:25 -0700108// event direction is bit[7] of eventType where 1b = Deassertion event
109constexpr static const uint8_t deassertionEvent = 0x80;
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800110
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700111static std::vector<uint8_t> fruCache;
Johnathan Mantey07574002022-12-13 14:52:54 -0800112static uint16_t cacheBus = 0xFFFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700113static uint8_t cacheAddr = 0XFF;
James Feiste4f710d2020-05-20 15:50:30 -0700114static uint8_t lastDevId = 0xFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700115
Johnathan Mantey07574002022-12-13 14:52:54 -0800116static uint16_t writeBus = 0xFFFF;
James Feist25690252019-12-23 12:25:49 -0800117static uint8_t writeAddr = 0XFF;
118
Patrick Williamsf0feb492023-12-05 12:45:02 -0600119std::unique_ptr<sdbusplus::Timer> writeTimer = nullptr;
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500120static std::vector<sdbusplus::bus::match_t> fruMatches;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700121
James Feist25690252019-12-23 12:25:49 -0800122ManagedObjectType frus;
123
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700124// we unfortunately have to build a map of hashes in case there is a
125// collision to verify our dev-id
Johnathan Mantey07574002022-12-13 14:52:54 -0800126boost::container::flat_map<uint8_t, std::pair<uint16_t, uint8_t>> deviceHashes;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700127
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700128void registerStorageFunctions() __attribute__((constructor));
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700129
130bool writeFru()
131{
Johnathan Mantey07574002022-12-13 14:52:54 -0800132 if (writeBus == 0xFFFF && writeAddr == 0xFF)
James Feist25690252019-12-23 12:25:49 -0800133 {
134 return true;
135 }
Vernon Mauery15419dd2019-05-24 09:40:30 -0700136 std::shared_ptr<sdbusplus::asio::connection> dbus = getSdBus();
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500137 sdbusplus::message_t writeFru = dbus->new_method_call(
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700138 fruDeviceServiceName, "/xyz/openbmc_project/FruDevice",
139 "xyz.openbmc_project.FruDeviceManager", "WriteFru");
James Feist25690252019-12-23 12:25:49 -0800140 writeFru.append(writeBus, writeAddr, fruCache);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700141 try
142 {
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500143 sdbusplus::message_t writeFruResp = dbus->call(writeFru);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700144 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500145 catch (const sdbusplus::exception_t&)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700146 {
147 // todo: log sel?
148 phosphor::logging::log<phosphor::logging::level::ERR>(
149 "error writing fru");
150 return false;
151 }
Johnathan Mantey07574002022-12-13 14:52:54 -0800152 writeBus = 0xFFFF;
James Feist25690252019-12-23 12:25:49 -0800153 writeAddr = 0xFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700154 return true;
155}
156
James Feist25690252019-12-23 12:25:49 -0800157void createTimers()
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700158{
Patrick Williamsf0feb492023-12-05 12:45:02 -0600159 writeTimer = std::make_unique<sdbusplus::Timer>(writeFru);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700160}
161
James Feiste4f710d2020-05-20 15:50:30 -0700162void recalculateHashes()
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700163{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700164 deviceHashes.clear();
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700165 // hash the object paths to create unique device id's. increment on
166 // collision
167 std::hash<std::string> hasher;
168 for (const auto& fru : frus)
169 {
170 auto fruIface = fru.second.find("xyz.openbmc_project.FruDevice");
171 if (fruIface == fru.second.end())
172 {
173 continue;
174 }
175
176 auto busFind = fruIface->second.find("BUS");
177 auto addrFind = fruIface->second.find("ADDRESS");
178 if (busFind == fruIface->second.end() ||
179 addrFind == fruIface->second.end())
180 {
181 phosphor::logging::log<phosphor::logging::level::INFO>(
182 "fru device missing Bus or Address",
183 phosphor::logging::entry("FRU=%s", fru.first.str.c_str()));
184 continue;
185 }
186
Johnathan Mantey07574002022-12-13 14:52:54 -0800187 uint16_t fruBus = std::get<uint32_t>(busFind->second);
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700188 uint8_t fruAddr = std::get<uint32_t>(addrFind->second);
Anoop S358e7df2020-05-05 16:43:34 +0000189 auto chassisFind = fruIface->second.find("CHASSIS_TYPE");
190 std::string chassisType;
191 if (chassisFind != fruIface->second.end())
192 {
193 chassisType = std::get<std::string>(chassisFind->second);
194 }
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700195
196 uint8_t fruHash = 0;
Anoop S358e7df2020-05-05 16:43:34 +0000197 if (chassisType.compare(chassisTypeRackMount) != 0)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700198 {
199 fruHash = hasher(fru.first.str);
200 // can't be 0xFF based on spec, and 0 is reserved for baseboard
201 if (fruHash == 0 || fruHash == 0xFF)
202 {
203 fruHash = 1;
204 }
205 }
Johnathan Mantey07574002022-12-13 14:52:54 -0800206 std::pair<uint16_t, uint8_t> newDev(fruBus, fruAddr);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700207
208 bool emplacePassed = false;
209 while (!emplacePassed)
210 {
211 auto resp = deviceHashes.emplace(fruHash, newDev);
212 emplacePassed = resp.second;
213 if (!emplacePassed)
214 {
215 fruHash++;
216 // can't be 0xFF based on spec, and 0 is reserved for
217 // baseboard
218 if (fruHash == 0XFF)
219 {
220 fruHash = 0x1;
221 }
222 }
223 }
224 }
James Feiste4f710d2020-05-20 15:50:30 -0700225}
226
227void replaceCacheFru(const std::shared_ptr<sdbusplus::asio::connection>& bus,
Archana Kakanif23fd542021-09-16 05:05:10 +0000228 boost::asio::yield_context& yield)
James Feiste4f710d2020-05-20 15:50:30 -0700229{
230 boost::system::error_code ec;
231
Johnathan Manteyee27fe02024-06-26 07:54:42 -0700232 frus = bus->yield_method_call<ManagedObjectType>(
233 yield, ec, fruDeviceServiceName, "/",
234 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
James Feiste4f710d2020-05-20 15:50:30 -0700235 if (ec)
236 {
237 phosphor::logging::log<phosphor::logging::level::ERR>(
Johnathan Manteyee27fe02024-06-26 07:54:42 -0700238 "GetMangagedObjects for getSensorMap failed",
James Feiste4f710d2020-05-20 15:50:30 -0700239 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
240
241 return;
242 }
243 recalculateHashes();
244}
245
Vernon Mauerydcff1502022-09-28 11:12:46 -0700246ipmi::Cc getFru(ipmi::Context::ptr& ctx, uint8_t devId)
James Feiste4f710d2020-05-20 15:50:30 -0700247{
248 if (lastDevId == devId && devId != 0xFF)
249 {
250 return ipmi::ccSuccess;
251 }
252
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700253 auto deviceFind = deviceHashes.find(devId);
Johnathan Manteyee27fe02024-06-26 07:54:42 -0700254 if (deviceFind == deviceHashes.end())
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700255 {
256 return IPMI_CC_SENSOR_INVALID;
257 }
258
PavanKumarIntel3432a0a2023-07-10 14:37:29 +0000259 if (writeTimer->isRunning())
260 {
261 phosphor::logging::log<phosphor::logging::level::ERR>(
262 "Couldn't get raw fru as fru is updating");
263 return ipmi::ccBusy;
264 }
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700265 fruCache.clear();
James Feist25690252019-12-23 12:25:49 -0800266
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700267 cacheBus = deviceFind->second.first;
268 cacheAddr = deviceFind->second.second;
James Feist25690252019-12-23 12:25:49 -0800269
James Feiste4f710d2020-05-20 15:50:30 -0700270 boost::system::error_code ec;
271
Johnathan Manteyee27fe02024-06-26 07:54:42 -0700272 fruCache = ctx->bus->yield_method_call<std::vector<uint8_t>>(
273 ctx->yield, ec, fruDeviceServiceName, "/xyz/openbmc_project/FruDevice",
274 "xyz.openbmc_project.FruDeviceManager", "GetRawFru", cacheBus,
275 cacheAddr);
James Feist25690252019-12-23 12:25:49 -0800276 if (ec)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700277 {
James Feist25690252019-12-23 12:25:49 -0800278 phosphor::logging::log<phosphor::logging::level::ERR>(
279 "Couldn't get raw fru",
280 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
Johnathan Mantey07574002022-12-13 14:52:54 -0800281 cacheBus = 0xFFFF;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700282 cacheAddr = 0xFF;
James Feist25690252019-12-23 12:25:49 -0800283 return ipmi::ccResponseError;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700284 }
285
286 lastDevId = devId;
James Feist25690252019-12-23 12:25:49 -0800287 return ipmi::ccSuccess;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700288}
289
James Feiste4f710d2020-05-20 15:50:30 -0700290void writeFruIfRunning()
291{
292 if (!writeTimer->isRunning())
293 {
294 return;
295 }
296 writeTimer->stop();
297 writeFru();
298}
299
300void startMatch(void)
301{
302 if (fruMatches.size())
303 {
304 return;
305 }
306
307 fruMatches.reserve(2);
308
309 auto bus = getSdBus();
Patrick Williams1bcced02024-08-16 15:20:24 -0400310 fruMatches.emplace_back(
311 *bus,
312 "type='signal',arg0path='/xyz/openbmc_project/"
313 "FruDevice/',member='InterfacesAdded'",
314 [](sdbusplus::message_t& message) {
315 sdbusplus::message::object_path path;
316 ObjectType object;
317 try
318 {
319 message.read(path, object);
320 }
321 catch (const sdbusplus::exception_t&)
322 {
323 return;
324 }
325 auto findType = object.find("xyz.openbmc_project.FruDevice");
326 if (findType == object.end())
327 {
328 return;
329 }
330 writeFruIfRunning();
331 frus[path] = object;
332 recalculateHashes();
333 lastDevId = 0xFF;
334 });
James Feiste4f710d2020-05-20 15:50:30 -0700335
Patrick Williams1bcced02024-08-16 15:20:24 -0400336 fruMatches.emplace_back(
337 *bus,
338 "type='signal',arg0path='/xyz/openbmc_project/"
339 "FruDevice/',member='InterfacesRemoved'",
340 [](sdbusplus::message_t& message) {
341 sdbusplus::message::object_path path;
342 std::set<std::string> interfaces;
343 try
344 {
345 message.read(path, interfaces);
346 }
347 catch (const sdbusplus::exception_t&)
348 {
349 return;
350 }
351 auto findType = interfaces.find("xyz.openbmc_project.FruDevice");
352 if (findType == interfaces.end())
353 {
354 return;
355 }
356 writeFruIfRunning();
357 frus.erase(path);
358 recalculateHashes();
359 lastDevId = 0xFF;
360 });
James Feiste4f710d2020-05-20 15:50:30 -0700361
362 // call once to populate
Jason M. Billsfb17ae12025-02-26 09:12:47 -0800363 boost::asio::spawn(
364 *getIoContext(),
365 [](boost::asio::yield_context yield) {
366 replaceCacheFru(getSdBus(), yield);
367 },
368 boost::asio::detached);
James Feiste4f710d2020-05-20 15:50:30 -0700369}
370
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000371/** @brief implements the read FRU data command
372 * @param fruDeviceId - FRU Device ID
373 * @param fruInventoryOffset - FRU Inventory Offset to write
374 * @param countToRead - Count to read
375 *
376 * @returns ipmi completion code plus response data
377 * - countWritten - Count written
378 */
379ipmi::RspType<uint8_t, // Count
380 std::vector<uint8_t> // Requested data
381 >
Vernon Mauerydcff1502022-09-28 11:12:46 -0700382 ipmiStorageReadFruData(ipmi::Context::ptr& ctx, uint8_t fruDeviceId,
James Feist25690252019-12-23 12:25:49 -0800383 uint16_t fruInventoryOffset, uint8_t countToRead)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700384{
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000385 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700386 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000387 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700388 }
389
James Feiste4f710d2020-05-20 15:50:30 -0700390 ipmi::Cc status = getFru(ctx, fruDeviceId);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700391
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000392 if (status != ipmi::ccSuccess)
393 {
394 return ipmi::response(status);
395 }
396
397 size_t fromFruByteLen = 0;
398 if (countToRead + fruInventoryOffset < fruCache.size())
399 {
400 fromFruByteLen = countToRead;
401 }
402 else if (fruCache.size() > fruInventoryOffset)
403 {
404 fromFruByteLen = fruCache.size() - fruInventoryOffset;
405 }
406 else
407 {
srikanta mondal92108382020-02-27 18:53:20 +0000408 return ipmi::responseReqDataLenExceeded();
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000409 }
410
411 std::vector<uint8_t> requestedData;
412
413 requestedData.insert(
414 requestedData.begin(), fruCache.begin() + fruInventoryOffset,
415 fruCache.begin() + fruInventoryOffset + fromFruByteLen);
416
Patrick Venture70b17f92019-10-28 20:01:53 -0700417 return ipmi::responseSuccess(static_cast<uint8_t>(requestedData.size()),
418 requestedData);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700419}
420
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000421/** @brief implements the write FRU data command
422 * @param fruDeviceId - FRU Device ID
423 * @param fruInventoryOffset - FRU Inventory Offset to write
424 * @param dataToWrite - Data to write
425 *
426 * @returns ipmi completion code plus response data
427 * - countWritten - Count written
428 */
Patrick Williams1bcced02024-08-16 15:20:24 -0400429ipmi::RspType<uint8_t> ipmiStorageWriteFruData(
430 ipmi::Context::ptr& ctx, uint8_t fruDeviceId, uint16_t fruInventoryOffset,
431 std::vector<uint8_t>& dataToWrite)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700432{
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000433 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700434 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000435 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700436 }
437
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000438 size_t writeLen = dataToWrite.size();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700439
James Feiste4f710d2020-05-20 15:50:30 -0700440 ipmi::Cc status = getFru(ctx, fruDeviceId);
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000441 if (status != ipmi::ccSuccess)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700442 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000443 return ipmi::response(status);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700444 }
Vernon Mauerydcff1502022-09-28 11:12:46 -0700445 size_t lastWriteAddr = fruInventoryOffset + writeLen;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700446 if (fruCache.size() < lastWriteAddr)
447 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000448 fruCache.resize(fruInventoryOffset + writeLen);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700449 }
450
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000451 std::copy(dataToWrite.begin(), dataToWrite.begin() + writeLen,
452 fruCache.begin() + fruInventoryOffset);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700453
Peter Foley21a1b5f2023-10-31 17:42:04 -0400454 bool atEnd = validateBasicFruContent(fruCache, lastWriteAddr);
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000455 uint8_t countWritten = 0;
James Feist25690252019-12-23 12:25:49 -0800456
457 writeBus = cacheBus;
458 writeAddr = cacheAddr;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700459 if (atEnd)
460 {
461 // cancel timer, we're at the end so might as well send it
James Feist25690252019-12-23 12:25:49 -0800462 writeTimer->stop();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700463 if (!writeFru())
464 {
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000465 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700466 }
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000467 countWritten = std::min(fruCache.size(), static_cast<size_t>(0xFF));
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700468 }
469 else
470 {
James Feist25690252019-12-23 12:25:49 -0800471 // start a timer, if no further data is sent to check to see if it is
472 // valid
473 writeTimer->start(std::chrono::duration_cast<std::chrono::microseconds>(
474 std::chrono::seconds(writeTimeoutSeconds)));
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000475 countWritten = 0;
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700476 }
477
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +0000478 return ipmi::responseSuccess(countWritten);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700479}
480
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000481/** @brief implements the get FRU inventory area info command
482 * @param fruDeviceId - FRU Device ID
483 *
484 * @returns IPMI completion code plus response data
485 * - inventorySize - Number of possible allocation units
486 * - accessType - Allocation unit size in bytes.
487 */
488ipmi::RspType<uint16_t, // inventorySize
489 uint8_t> // accessType
Vernon Mauerydcff1502022-09-28 11:12:46 -0700490 ipmiStorageGetFruInvAreaInfo(ipmi::Context::ptr& ctx, uint8_t fruDeviceId)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700491{
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000492 if (fruDeviceId == 0xFF)
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700493 {
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000494 return ipmi::responseInvalidFieldRequest();
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700495 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700496
Jayaprakash Mutyala1e2ab062020-08-03 16:57:00 +0000497 ipmi::Cc ret = getFru(ctx, fruDeviceId);
498 if (ret != ipmi::ccSuccess)
499 {
500 return ipmi::response(ret);
501 }
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700502
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000503 constexpr uint8_t accessType =
504 static_cast<uint8_t>(GetFRUAreaAccessType::byte);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700505
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +0000506 return ipmi::responseSuccess(fruCache.size(), accessType);
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700507}
508
Vernon Mauerydcff1502022-09-28 11:12:46 -0700509ipmi::Cc getFruSdrCount(ipmi::Context::ptr&, size_t& count)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700510{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700511 count = deviceHashes.size();
Vernon Mauerydcff1502022-09-28 11:12:46 -0700512 return ipmi::ccSuccess;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700513}
514
Vernon Mauerydcff1502022-09-28 11:12:46 -0700515ipmi::Cc getFruSdrs(ipmi::Context::ptr& ctx, size_t index,
516 get_sdr::SensorDataFruRecord& resp)
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700517{
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700518 if (deviceHashes.size() < index)
519 {
Vernon Mauerydcff1502022-09-28 11:12:46 -0700520 return ipmi::ccInvalidFieldRequest;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700521 }
522 auto device = deviceHashes.begin() + index;
Johnathan Mantey07574002022-12-13 14:52:54 -0800523 uint16_t& bus = device->second.first;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700524 uint8_t& address = device->second.second;
525
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700526 boost::container::flat_map<std::string, DbusVariant>* fruData = nullptr;
Patrick Williams1bcced02024-08-16 15:20:24 -0400527 auto fru = std::find_if(
528 frus.begin(), frus.end(),
529 [bus, address, &fruData](ManagedEntry& entry) {
530 auto findFruDevice =
531 entry.second.find("xyz.openbmc_project.FruDevice");
532 if (findFruDevice == entry.second.end())
533 {
534 return false;
535 }
536 fruData = &(findFruDevice->second);
537 auto findBus = findFruDevice->second.find("BUS");
538 auto findAddress = findFruDevice->second.find("ADDRESS");
539 if (findBus == findFruDevice->second.end() ||
540 findAddress == findFruDevice->second.end())
541 {
542 return false;
543 }
544 if (std::get<uint32_t>(findBus->second) != bus)
545 {
546 return false;
547 }
548 if (std::get<uint32_t>(findAddress->second) != address)
549 {
550 return false;
551 }
552 return true;
553 });
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700554 if (fru == frus.end())
555 {
Vernon Mauerydcff1502022-09-28 11:12:46 -0700556 return ipmi::ccResponseError;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700557 }
Patrick Venture9ce789f2019-10-17 09:09:39 -0700558
James Feist25690252019-12-23 12:25:49 -0800559#ifdef USING_ENTITY_MANAGER_DECORATORS
560
Patrick Venture9ce789f2019-10-17 09:09:39 -0700561 boost::container::flat_map<std::string, DbusVariant>* entityData = nullptr;
Patrick Venture9ce789f2019-10-17 09:09:39 -0700562
James Feist25690252019-12-23 12:25:49 -0800563 // todo: this should really use caching, this is a very inefficient lookup
564 boost::system::error_code ec;
565 ManagedObjectType entities = ctx->bus->yield_method_call<ManagedObjectType>(
Nan Zhou9d2894d2022-09-20 22:22:00 +0000566 ctx->yield, ec, "xyz.openbmc_project.EntityManager",
567 "/xyz/openbmc_project/inventory", "org.freedesktop.DBus.ObjectManager",
568 "GetManagedObjects");
James Feist25690252019-12-23 12:25:49 -0800569
570 if (ec)
Patrick Venture9ce789f2019-10-17 09:09:39 -0700571 {
James Feist25690252019-12-23 12:25:49 -0800572 phosphor::logging::log<phosphor::logging::level::ERR>(
573 "GetMangagedObjects for getSensorMap failed",
574 phosphor::logging::entry("ERROR=%s", ec.message().c_str()));
Patrick Venture9ce789f2019-10-17 09:09:39 -0700575
James Feist25690252019-12-23 12:25:49 -0800576 return ipmi::ccResponseError;
577 }
Patrick Venture9ce789f2019-10-17 09:09:39 -0700578
Patrick Williams1bcced02024-08-16 15:20:24 -0400579 auto entity = std::find_if(
580 entities.begin(), entities.end(),
581 [bus, address, &entityData](ManagedEntry& entry) {
582 auto findFruDevice = entry.second.find(
583 "xyz.openbmc_project.Inventory.Decorator.FruDevice");
584 if (findFruDevice == entry.second.end())
585 {
586 return false;
587 }
James Feist25690252019-12-23 12:25:49 -0800588
Patrick Williams1bcced02024-08-16 15:20:24 -0400589 // Integer fields added via Entity-Manager json are uint64_ts by
590 // default.
591 auto findBus = findFruDevice->second.find("Bus");
592 auto findAddress = findFruDevice->second.find("Address");
James Feist25690252019-12-23 12:25:49 -0800593
Patrick Williams1bcced02024-08-16 15:20:24 -0400594 if (findBus == findFruDevice->second.end() ||
595 findAddress == findFruDevice->second.end())
596 {
597 return false;
598 }
599 if ((std::get<uint64_t>(findBus->second) != bus) ||
600 (std::get<uint64_t>(findAddress->second) != address))
601 {
602 return false;
603 }
James Feist25690252019-12-23 12:25:49 -0800604
Patrick Williams1bcced02024-08-16 15:20:24 -0400605 // At this point we found the device entry and should return
606 // true.
607 auto findIpmiDevice = entry.second.find(
608 "xyz.openbmc_project.Inventory.Decorator.Ipmi");
609 if (findIpmiDevice != entry.second.end())
610 {
611 entityData = &(findIpmiDevice->second);
612 }
James Feist25690252019-12-23 12:25:49 -0800613
Patrick Williams1bcced02024-08-16 15:20:24 -0400614 return true;
615 });
James Feist25690252019-12-23 12:25:49 -0800616
617 if (entity == entities.end())
618 {
619 if constexpr (DEBUG)
620 {
621 std::fprintf(stderr, "Ipmi or FruDevice Decorator interface "
622 "not found for Fru\n");
Patrick Venture9ce789f2019-10-17 09:09:39 -0700623 }
624 }
James Feist25690252019-12-23 12:25:49 -0800625
626#endif
Patrick Venture9ce789f2019-10-17 09:09:39 -0700627
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700628 std::string name;
629 auto findProductName = fruData->find("BOARD_PRODUCT_NAME");
630 auto findBoardName = fruData->find("PRODUCT_PRODUCT_NAME");
631 if (findProductName != fruData->end())
632 {
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700633 name = std::get<std::string>(findProductName->second);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700634 }
635 else if (findBoardName != fruData->end())
636 {
Vernon Mauery8166c8d2019-05-23 11:22:30 -0700637 name = std::get<std::string>(findBoardName->second);
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700638 }
639 else
640 {
641 name = "UNKNOWN";
642 }
643 if (name.size() > maxFruSdrNameSize)
644 {
645 name = name.substr(0, maxFruSdrNameSize);
646 }
647 size_t sizeDiff = maxFruSdrNameSize - name.size();
648
649 resp.header.record_id_lsb = 0x0; // calling code is to implement these
650 resp.header.record_id_msb = 0x0;
651 resp.header.sdr_version = ipmiSdrVersion;
Patrick Venture73d01352019-10-11 18:32:59 -0700652 resp.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700653 resp.header.record_length = sizeof(resp.body) + sizeof(resp.key) - sizeDiff;
654 resp.key.deviceAddress = 0x20;
655 resp.key.fruID = device->first;
656 resp.key.accessLun = 0x80; // logical / physical fru device
657 resp.key.channelNumber = 0x0;
658 resp.body.reserved = 0x0;
659 resp.body.deviceType = 0x10;
James Feist4f86d1f2019-04-03 10:30:26 -0700660 resp.body.deviceTypeModifier = 0x0;
Patrick Venture9ce789f2019-10-17 09:09:39 -0700661
662 uint8_t entityID = 0;
663 uint8_t entityInstance = 0x1;
664
James Feist25690252019-12-23 12:25:49 -0800665#ifdef USING_ENTITY_MANAGER_DECORATORS
Patrick Venture9ce789f2019-10-17 09:09:39 -0700666 if (entityData)
667 {
668 auto entityIdProperty = entityData->find("EntityId");
669 auto entityInstanceProperty = entityData->find("EntityInstance");
670
671 if (entityIdProperty != entityData->end())
672 {
673 entityID = static_cast<uint8_t>(
674 std::get<uint64_t>(entityIdProperty->second));
675 }
676 if (entityInstanceProperty != entityData->end())
677 {
678 entityInstance = static_cast<uint8_t>(
679 std::get<uint64_t>(entityInstanceProperty->second));
680 }
681 }
James Feist25690252019-12-23 12:25:49 -0800682#endif
Patrick Venture9ce789f2019-10-17 09:09:39 -0700683
684 resp.body.entityID = entityID;
685 resp.body.entityInstance = entityInstance;
686
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700687 resp.body.oem = 0x0;
688 resp.body.deviceIDLen = name.size();
689 name.copy(resp.body.deviceID, name.size());
690
Vernon Mauerydcff1502022-09-28 11:12:46 -0700691 return ipmi::ccSuccess;
Jason M. Bills3f7c5e42018-10-03 14:00:41 -0700692}
Jason M. Billse2d1aee2018-10-03 15:57:18 -0700693
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700694static bool getSELLogFiles(std::vector<std::filesystem::path>& selLogFiles)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800695{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700696 // Loop through the directory looking for ipmi_sel log files
697 for (const std::filesystem::directory_entry& dirEnt :
698 std::filesystem::directory_iterator(intel_oem::ipmi::sel::selLogDir))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800699 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700700 std::string filename = dirEnt.path().filename();
701 if (boost::starts_with(filename, intel_oem::ipmi::sel::selLogFilename))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800702 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700703 // If we find an ipmi_sel log file, save the path
Patrick Williams1bcced02024-08-16 15:20:24 -0400704 selLogFiles.emplace_back(
705 intel_oem::ipmi::sel::selLogDir / filename);
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800706 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800707 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700708 // As the log files rotate, they are appended with a ".#" that is higher for
709 // the older logs. Since we don't expect more than 10 log files, we
710 // can just sort the list to get them in order from newest to oldest
711 std::sort(selLogFiles.begin(), selLogFiles.end());
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800712
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700713 return !selLogFiles.empty();
714}
715
716static int countSELEntries()
717{
718 // Get the list of ipmi_sel log files
719 std::vector<std::filesystem::path> selLogFiles;
720 if (!getSELLogFiles(selLogFiles))
721 {
722 return 0;
723 }
724 int numSELEntries = 0;
725 // Loop through each log file and count the number of logs
726 for (const std::filesystem::path& file : selLogFiles)
727 {
728 std::ifstream logStream(file);
729 if (!logStream.is_open())
730 {
731 continue;
732 }
733
734 std::string line;
735 while (std::getline(logStream, line))
736 {
737 numSELEntries++;
738 }
739 }
740 return numSELEntries;
741}
742
743static bool findSELEntry(const int recordID,
Patrick Ventureff7e15b2019-09-25 16:48:26 -0700744 const std::vector<std::filesystem::path>& selLogFiles,
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700745 std::string& entry)
746{
747 // Record ID is the first entry field following the timestamp. It is
748 // preceded by a space and followed by a comma
749 std::string search = " " + std::to_string(recordID) + ",";
750
751 // Loop through the ipmi_sel log entries
752 for (const std::filesystem::path& file : selLogFiles)
753 {
754 std::ifstream logStream(file);
755 if (!logStream.is_open())
756 {
757 continue;
758 }
759
760 while (std::getline(logStream, entry))
761 {
762 // Check if the record ID matches
763 if (entry.find(search) != std::string::npos)
764 {
765 return true;
766 }
767 }
768 }
769 return false;
770}
771
Jason M. Bills97d1fb32025-04-23 08:57:35 -0700772static uint16_t getNextRecordID(
773 const uint16_t recordID,
774 const std::vector<std::filesystem::path>& selLogFiles)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700775{
776 uint16_t nextRecordID = recordID + 1;
777 std::string entry;
778 if (findSELEntry(nextRecordID, selLogFiles, entry))
779 {
780 return nextRecordID;
781 }
782 else
783 {
784 return ipmi::sel::lastEntry;
785 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800786}
787
Patrick Ventureff7e15b2019-09-25 16:48:26 -0700788static int fromHexStr(const std::string& hexStr, std::vector<uint8_t>& data)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800789{
790 for (unsigned int i = 0; i < hexStr.size(); i += 2)
791 {
792 try
793 {
794 data.push_back(static_cast<uint8_t>(
795 std::stoul(hexStr.substr(i, 2), nullptr, 16)));
796 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500797 catch (const std::invalid_argument& e)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800798 {
799 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
800 return -1;
801 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500802 catch (const std::out_of_range& e)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800803 {
804 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
805 return -1;
806 }
807 }
808 return 0;
809}
810
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700811ipmi::RspType<uint8_t, // SEL version
812 uint16_t, // SEL entry count
813 uint16_t, // free space
814 uint32_t, // last add timestamp
815 uint32_t, // last erase timestamp
816 uint8_t> // operation support
817 ipmiStorageGetSELInfo()
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800818{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700819 constexpr uint8_t selVersion = ipmi::sel::selVersion;
820 uint16_t entries = countSELEntries();
821 uint32_t addTimeStamp = intel_oem::ipmi::sel::getFileTimestamp(
822 intel_oem::ipmi::sel::selLogDir / intel_oem::ipmi::sel::selLogFilename);
823 uint32_t eraseTimeStamp = intel_oem::ipmi::sel::erase_time::get();
824 constexpr uint8_t operationSupport =
825 intel_oem::ipmi::sel::selOperationSupport;
826 constexpr uint16_t freeSpace =
827 0xffff; // Spec indicates that more than 64kB is free
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800828
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700829 return ipmi::responseSuccess(selVersion, entries, freeSpace, addTimeStamp,
830 eraseTimeStamp, operationSupport);
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800831}
832
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700833using systemEventType = std::tuple<
834 uint32_t, // Timestamp
835 uint16_t, // Generator ID
836 uint8_t, // EvM Rev
837 uint8_t, // Sensor Type
838 uint8_t, // Sensor Number
839 uint7_t, // Event Type
840 bool, // Event Direction
841 std::array<uint8_t, intel_oem::ipmi::sel::systemEventSize>>; // Event Data
842using oemTsEventType = std::tuple<
Patrick Williamsb37abfb2023-05-10 07:50:33 -0500843 uint32_t, // Timestamp
844 std::array<uint8_t, intel_oem::ipmi::sel::oemTsEventSize>>; // Event Data
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700845using oemEventType =
Patrick Williamsb37abfb2023-05-10 07:50:33 -0500846 std::array<uint8_t, intel_oem::ipmi::sel::oemEventSize>; // Event Data
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800847
Patrick Williamsb37abfb2023-05-10 07:50:33 -0500848ipmi::RspType<uint16_t, // Next Record ID
849 uint16_t, // Record ID
850 uint8_t, // Record Type
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700851 std::variant<systemEventType, oemTsEventType,
852 oemEventType>> // Record Content
853 ipmiStorageGetSELEntry(uint16_t reservationID, uint16_t targetID,
854 uint8_t offset, uint8_t size)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800855{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700856 // Only support getting the entire SEL record. If a partial size or non-zero
857 // offset is requested, return an error
858 if (offset != 0 || size != ipmi::sel::entireRecord)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800859 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700860 return ipmi::responseRetBytesUnavailable();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800861 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800862
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700863 // Check the reservation ID if one is provided or required (only if the
864 // offset is non-zero)
865 if (reservationID != 0 || offset != 0)
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800866 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700867 if (!checkSELReservation(reservationID))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800868 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700869 return ipmi::responseInvalidReservationId();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800870 }
871 }
872
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700873 // Get the ipmi_sel log files
874 std::vector<std::filesystem::path> selLogFiles;
875 if (!getSELLogFiles(selLogFiles))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800876 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700877 return ipmi::responseSensorInvalid();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800878 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800879
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700880 std::string targetEntry;
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800881
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800882 if (targetID == ipmi::sel::firstEntry)
883 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700884 // The first entry will be at the top of the oldest log file
885 std::ifstream logStream(selLogFiles.back());
886 if (!logStream.is_open())
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800887 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700888 return ipmi::responseUnspecifiedError();
889 }
890
891 if (!std::getline(logStream, targetEntry))
892 {
893 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800894 }
895 }
896 else if (targetID == ipmi::sel::lastEntry)
897 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700898 // The last entry will be at the bottom of the newest log file
899 std::ifstream logStream(selLogFiles.front());
900 if (!logStream.is_open())
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800901 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700902 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800903 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700904
905 std::string line;
906 while (std::getline(logStream, line))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800907 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700908 targetEntry = line;
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800909 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800910 }
911 else
912 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700913 if (!findSELEntry(targetID, selLogFiles, targetEntry))
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800914 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700915 return ipmi::responseSensorInvalid();
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800916 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -0800917 }
918
Jason M. Bills52aaa7d2019-05-08 15:21:39 -0700919 // The format of the ipmi_sel message is "<Timestamp>
920 // <ID>,<Type>,<EventData>,[<Generator ID>,<Path>,<Direction>]".
921 // First get the Timestamp
922 size_t space = targetEntry.find_first_of(" ");
923 if (space == std::string::npos)
924 {
925 return ipmi::responseUnspecifiedError();
926 }
927 std::string entryTimestamp = targetEntry.substr(0, space);
928 // Then get the log contents
929 size_t entryStart = targetEntry.find_first_not_of(" ", space);
930 if (entryStart == std::string::npos)
931 {
932 return ipmi::responseUnspecifiedError();
933 }
934 std::string_view entry(targetEntry);
935 entry.remove_prefix(entryStart);
936 // Use split to separate the entry into its fields
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700937 std::vector<std::string> targetEntryFields;
Jason M. Bills52aaa7d2019-05-08 15:21:39 -0700938 boost::split(targetEntryFields, entry, boost::is_any_of(","),
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700939 boost::token_compress_on);
Jason M. Bills52aaa7d2019-05-08 15:21:39 -0700940 if (targetEntryFields.size() < 3)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700941 {
942 return ipmi::responseUnspecifiedError();
943 }
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700944 std::string& recordIDStr = targetEntryFields[0];
945 std::string& recordTypeStr = targetEntryFields[1];
946 std::string& eventDataStr = targetEntryFields[2];
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700947
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700948 uint16_t recordID;
949 uint8_t recordType;
950 try
951 {
952 recordID = std::stoul(recordIDStr);
953 recordType = std::stoul(recordTypeStr, nullptr, 16);
954 }
955 catch (const std::invalid_argument&)
956 {
957 return ipmi::responseUnspecifiedError();
958 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700959 uint16_t nextRecordID = getNextRecordID(recordID, selLogFiles);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700960 std::vector<uint8_t> eventDataBytes;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700961 if (fromHexStr(eventDataStr, eventDataBytes) < 0)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700962 {
963 return ipmi::responseUnspecifiedError();
964 }
965
966 if (recordType == intel_oem::ipmi::sel::systemEvent)
967 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700968 // Get the timestamp
969 std::tm timeStruct = {};
Jason M. Bills52aaa7d2019-05-08 15:21:39 -0700970 std::istringstream entryStream(entryTimestamp);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700971
972 uint32_t timestamp = ipmi::sel::invalidTimeStamp;
973 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
974 {
975 timestamp = std::mktime(&timeStruct);
976 }
977
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700978 // Set the event message revision
979 uint8_t evmRev = intel_oem::ipmi::sel::eventMsgRev;
980
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700981 uint16_t generatorID = 0;
982 uint8_t sensorType = 0;
Johnathan Mantey308c3a82020-07-22 11:50:54 -0700983 uint16_t sensorAndLun = 0;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700984 uint8_t sensorNum = 0xFF;
985 uint7_t eventType = 0;
986 bool eventDir = 0;
987 // System type events should have six fields
988 if (targetEntryFields.size() >= 6)
989 {
990 std::string& generatorIDStr = targetEntryFields[3];
991 std::string& sensorPath = targetEntryFields[4];
992 std::string& eventDirStr = targetEntryFields[5];
Jason M. Bills1d4d54d2019-04-23 11:26:11 -0700993
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -0700994 // Get the generator ID
995 try
996 {
997 generatorID = std::stoul(generatorIDStr, nullptr, 16);
998 }
999 catch (const std::invalid_argument&)
1000 {
1001 std::cerr << "Invalid Generator ID\n";
1002 }
1003
1004 // Get the sensor type, sensor number, and event type for the sensor
1005 sensorType = getSensorTypeFromPath(sensorPath);
Johnathan Mantey308c3a82020-07-22 11:50:54 -07001006 sensorAndLun = getSensorNumberFromPath(sensorPath);
1007 sensorNum = static_cast<uint8_t>(sensorAndLun);
1008 generatorID |= sensorAndLun >> 8;
Jason M. Bills1a2fbdd2019-05-10 09:05:37 -07001009 eventType = getSensorEventTypeFromPath(sensorPath);
1010
1011 // Get the event direction
1012 try
1013 {
1014 eventDir = std::stoul(eventDirStr) ? 0 : 1;
1015 }
1016 catch (const std::invalid_argument&)
1017 {
1018 std::cerr << "Invalid Event Direction\n";
1019 }
1020 }
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001021
1022 // Only keep the eventData bytes that fit in the record
1023 std::array<uint8_t, intel_oem::ipmi::sel::systemEventSize> eventData{};
1024 std::copy_n(eventDataBytes.begin(),
1025 std::min(eventDataBytes.size(), eventData.size()),
1026 eventData.begin());
1027
1028 return ipmi::responseSuccess(
1029 nextRecordID, recordID, recordType,
1030 systemEventType{timestamp, generatorID, evmRev, sensorType,
1031 sensorNum, eventType, eventDir, eventData});
1032 }
1033 else if (recordType >= intel_oem::ipmi::sel::oemTsEventFirst &&
1034 recordType <= intel_oem::ipmi::sel::oemTsEventLast)
1035 {
1036 // Get the timestamp
1037 std::tm timeStruct = {};
Jason M. Bills52aaa7d2019-05-08 15:21:39 -07001038 std::istringstream entryStream(entryTimestamp);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001039
1040 uint32_t timestamp = ipmi::sel::invalidTimeStamp;
1041 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
1042 {
1043 timestamp = std::mktime(&timeStruct);
1044 }
1045
1046 // Only keep the bytes that fit in the record
1047 std::array<uint8_t, intel_oem::ipmi::sel::oemTsEventSize> eventData{};
1048 std::copy_n(eventDataBytes.begin(),
1049 std::min(eventDataBytes.size(), eventData.size()),
1050 eventData.begin());
1051
1052 return ipmi::responseSuccess(nextRecordID, recordID, recordType,
1053 oemTsEventType{timestamp, eventData});
1054 }
Patrick Venturec5136aa2019-10-04 20:39:31 -07001055 else if (recordType >= intel_oem::ipmi::sel::oemEventFirst)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001056 {
1057 // Only keep the bytes that fit in the record
1058 std::array<uint8_t, intel_oem::ipmi::sel::oemEventSize> eventData{};
1059 std::copy_n(eventDataBytes.begin(),
1060 std::min(eventDataBytes.size(), eventData.size()),
1061 eventData.begin());
1062
1063 return ipmi::responseSuccess(nextRecordID, recordID, recordType,
1064 eventData);
1065 }
1066
1067 return ipmi::responseUnspecifiedError();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001068}
1069
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001070ipmi::RspType<uint16_t> ipmiStorageAddSELEntry(
1071 uint16_t recordID, uint8_t recordType, uint32_t timestamp,
1072 uint16_t generatorID, uint8_t evmRev, uint8_t sensorType, uint8_t sensorNum,
1073 uint8_t eventType, uint8_t eventData1, uint8_t eventData2,
1074 uint8_t eventData3)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001075{
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001076 // Per the IPMI spec, need to cancel any reservation when a SEL entry is
1077 // added
1078 cancelSELReservation();
1079
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001080 // Send this request to the Redfish hooks to log it as a Redfish message
1081 // instead. There is no need to add it to the SEL, so just return success.
1082 intel_oem::ipmi::sel::checkRedfishHooks(
1083 recordID, recordType, timestamp, generatorID, evmRev, sensorType,
1084 sensorNum, eventType, eventData1, eventData2, eventData3);
Jason M. Bills99b78ec2019-01-18 10:42:18 -08001085
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001086 uint16_t responseID = 0xFFFF;
1087 return ipmi::responseSuccess(responseID);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001088}
1089
Patrick Williams1bcced02024-08-16 15:20:24 -04001090ipmi::RspType<uint8_t> ipmiStorageClearSEL(
1091 ipmi::Context::ptr&, uint16_t reservationID,
1092 const std::array<uint8_t, 3>& clr, uint8_t eraseOperation)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001093{
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001094 if (!checkSELReservation(reservationID))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001095 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001096 return ipmi::responseInvalidReservationId();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001097 }
1098
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001099 static constexpr std::array<uint8_t, 3> clrExpected = {'C', 'L', 'R'};
1100 if (clr != clrExpected)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001101 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001102 return ipmi::responseInvalidFieldRequest();
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001103 }
1104
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001105 // Erasure status cannot be fetched, so always return erasure status as
1106 // `erase completed`.
1107 if (eraseOperation == ipmi::sel::getEraseStatus)
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001108 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001109 return ipmi::responseSuccess(ipmi::sel::eraseComplete);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001110 }
1111
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001112 // Check that initiate erase is correct
1113 if (eraseOperation != ipmi::sel::initiateErase)
1114 {
1115 return ipmi::responseInvalidFieldRequest();
1116 }
1117
1118 // Per the IPMI spec, need to cancel any reservation when the SEL is
1119 // cleared
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001120 cancelSELReservation();
1121
Jason M. Bills7944c302019-03-20 15:24:05 -07001122 // Save the erase time
1123 intel_oem::ipmi::sel::erase_time::save();
1124
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001125 // Clear the SEL by deleting the log files
1126 std::vector<std::filesystem::path> selLogFiles;
1127 if (getSELLogFiles(selLogFiles))
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001128 {
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001129 for (const std::filesystem::path& file : selLogFiles)
1130 {
1131 std::error_code ec;
1132 std::filesystem::remove(file, ec);
1133 }
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001134 }
1135
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001136 // Reload rsyslog so it knows to start new log files
Vernon Mauery15419dd2019-05-24 09:40:30 -07001137 std::shared_ptr<sdbusplus::asio::connection> dbus = getSdBus();
Patrick Williamsf944d2e2022-07-22 19:26:52 -05001138 sdbusplus::message_t rsyslogReload = dbus->new_method_call(
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001139 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1140 "org.freedesktop.systemd1.Manager", "ReloadUnit");
1141 rsyslogReload.append("rsyslog.service", "replace");
1142 try
1143 {
Patrick Williamsf944d2e2022-07-22 19:26:52 -05001144 sdbusplus::message_t reloadResponse = dbus->call(rsyslogReload);
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001145 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -05001146 catch (const sdbusplus::exception_t& e)
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001147 {
1148 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
1149 }
1150
1151 return ipmi::responseSuccess(ipmi::sel::eraseComplete);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001152}
1153
Jason M. Bills1a474622019-06-14 14:51:33 -07001154ipmi::RspType<uint32_t> ipmiStorageGetSELTime()
1155{
1156 struct timespec selTime = {};
1157
1158 if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
1159 {
1160 return ipmi::responseUnspecifiedError();
1161 }
1162
1163 return ipmi::responseSuccess(selTime.tv_sec);
1164}
1165
Vernon Mauerydcff1502022-09-28 11:12:46 -07001166ipmi::RspType<> ipmiStorageSetSELTime([[maybe_unused]] uint32_t selTime)
Jason M. Billscac97a52019-01-30 14:43:46 -08001167{
1168 // Set SEL Time is not supported
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001169 return ipmi::responseInvalidCommand();
Jason M. Billscac97a52019-01-30 14:43:46 -08001170}
1171
James Feist74c50c62019-08-14 14:18:41 -07001172std::vector<uint8_t> getType12SDRs(uint16_t index, uint16_t recordId)
1173{
1174 std::vector<uint8_t> resp;
1175 if (index == 0)
1176 {
James Feist74c50c62019-08-14 14:18:41 -07001177 std::string bmcName = "Basbrd Mgmt Ctlr";
Johnathan Manteyf4d5e052021-09-22 12:58:08 -07001178 Type12Record bmc(recordId, 0x20, 0, 0, 0xbf, 0x2e, 1, 0, bmcName);
James Feist74c50c62019-08-14 14:18:41 -07001179 uint8_t* bmcPtr = reinterpret_cast<uint8_t*>(&bmc);
1180 resp.insert(resp.end(), bmcPtr, bmcPtr + sizeof(Type12Record));
1181 }
1182 else if (index == 1)
1183 {
James Feist74c50c62019-08-14 14:18:41 -07001184 std::string meName = "Mgmt Engine";
Johnathan Manteyf4d5e052021-09-22 12:58:08 -07001185 Type12Record me(recordId, 0x2c, 6, 0x24, 0x21, 0x2e, 2, 0, meName);
James Feist74c50c62019-08-14 14:18:41 -07001186 uint8_t* mePtr = reinterpret_cast<uint8_t*>(&me);
1187 resp.insert(resp.end(), mePtr, mePtr + sizeof(Type12Record));
1188 }
1189 else
1190 {
Patrick Williams1bcced02024-08-16 15:20:24 -04001191 throw std::runtime_error(
1192 "getType12SDRs:: Illegal index " + std::to_string(index));
James Feist74c50c62019-08-14 14:18:41 -07001193 }
1194
1195 return resp;
1196}
1197
Yong Lifee5e4c2020-01-17 19:36:29 +08001198std::vector<uint8_t> getNMDiscoverySDR(uint16_t index, uint16_t recordId)
1199{
1200 std::vector<uint8_t> resp;
1201 if (index == 0)
1202 {
1203 NMDiscoveryRecord nm = {};
1204 nm.header.record_id_lsb = recordId;
1205 nm.header.record_id_msb = recordId >> 8;
1206 nm.header.sdr_version = ipmiSdrVersion;
1207 nm.header.record_type = 0xC0;
1208 nm.header.record_length = 0xB;
1209 nm.oemID0 = 0x57;
1210 nm.oemID1 = 0x1;
1211 nm.oemID2 = 0x0;
1212 nm.subType = 0x0D;
1213 nm.version = 0x1;
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001214 nm.targetAddress = 0x2C;
Yong Lifee5e4c2020-01-17 19:36:29 +08001215 nm.channelNumber = 0x60;
1216 nm.healthEventSensor = 0x19;
1217 nm.exceptionEventSensor = 0x18;
1218 nm.operationalCapSensor = 0x1A;
1219 nm.thresholdExceededSensor = 0x1B;
1220
1221 uint8_t* nmPtr = reinterpret_cast<uint8_t*>(&nm);
1222 resp.insert(resp.end(), nmPtr, nmPtr + sizeof(NMDiscoveryRecord));
1223 }
1224 else
1225 {
Patrick Williams1bcced02024-08-16 15:20:24 -04001226 throw std::runtime_error(
1227 "getNMDiscoverySDR:: Illegal index " + std::to_string(index));
Yong Lifee5e4c2020-01-17 19:36:29 +08001228 }
1229
1230 return resp;
1231}
1232
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001233void registerStorageFunctions()
1234{
James Feist25690252019-12-23 12:25:49 -08001235 createTimers();
James Feiste4f710d2020-05-20 15:50:30 -07001236 startMatch();
1237
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001238 // <Get FRU Inventory Area Info>
jayaprakash Mutyalad33acd62019-05-17 19:37:25 +00001239 ipmi::registerHandler(ipmi::prioOemBase, ipmi::netFnStorage,
1240 ipmi::storage::cmdGetFruInventoryAreaInfo,
1241 ipmi::Privilege::User, ipmiStorageGetFruInvAreaInfo);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001242 // <READ FRU Data>
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +00001243 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1244 ipmi::storage::cmdReadFruData, ipmi::Privilege::User,
1245 ipmiStorageReadFruData);
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001246
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001247 // <WRITE FRU Data>
jayaprakash Mutyala5f4194e2019-05-20 16:17:01 +00001248 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1249 ipmi::storage::cmdWriteFruData,
1250 ipmi::Privilege::Operator, ipmiStorageWriteFruData);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001251
1252 // <Get SEL Info>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001253 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001254 ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
1255 ipmiStorageGetSELInfo);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001256
1257 // <Get SEL Entry>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001258 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001259 ipmi::storage::cmdGetSelEntry, ipmi::Privilege::User,
1260 ipmiStorageGetSELEntry);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001261
1262 // <Add SEL Entry>
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001263 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Vernon Mauery98bbf692019-09-16 11:14:59 -07001264 ipmi::storage::cmdAddSelEntry,
Jason M. Bills6dd8f042019-04-11 10:39:02 -07001265 ipmi::Privilege::Operator, ipmiStorageAddSELEntry);
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001266
1267 // <Clear SEL>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001268 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1269 ipmi::storage::cmdClearSel, ipmi::Privilege::Operator,
1270 ipmiStorageClearSEL);
Jason M. Billscac97a52019-01-30 14:43:46 -08001271
Jason M. Bills1a474622019-06-14 14:51:33 -07001272 // <Get SEL Time>
1273 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
Jason M. Bills542498e2019-06-24 16:57:42 -07001274 ipmi::storage::cmdGetSelTime, ipmi::Privilege::User,
1275 ipmiStorageGetSELTime);
Jason M. Bills1a474622019-06-14 14:51:33 -07001276
Jason M. Billscac97a52019-01-30 14:43:46 -08001277 // <Set SEL Time>
Jason M. Bills1d4d54d2019-04-23 11:26:11 -07001278 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
1279 ipmi::storage::cmdSetSelTime,
1280 ipmi::Privilege::Operator, ipmiStorageSetSELTime);
Jason M. Billse2d1aee2018-10-03 15:57:18 -07001281}
Jason M. Bills3f7c5e42018-10-03 14:00:41 -07001282} // namespace storage
Jason M. Billsc04e2e72018-11-28 15:15:56 -08001283} // namespace ipmi