blob: 323c22ae387ac6607c6048484cbdd9297dd8886b [file] [log] [blame]
Ed Tanous1da66f72018-07-27 16:13:37 -07001/*
2// Copyright (c) 2018 Intel Corporation
3//
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#pragma once
17
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080018#include "app.hpp"
George Liu7a1dbc42022-12-07 16:03:22 +080019#include "dbus_utility.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080020#include "error_messages.hpp"
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -060021#include "generated/enums/log_entry.hpp"
Spencer Kub7028eb2021-10-26 15:27:35 +080022#include "gzfile.hpp"
George Liu647b3cd2021-07-05 12:43:56 +080023#include "http_utility.hpp"
Spencer Kub7028eb2021-10-26 15:27:35 +080024#include "human_sort.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080025#include "query.hpp"
Jason M. Bills4851d452019-03-28 11:27:48 -070026#include "registries.hpp"
27#include "registries/base_message_registry.hpp"
28#include "registries/openbmc_message_registry.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080029#include "registries/privilege_registry.hpp"
James Feist46229572020-02-19 15:11:58 -080030#include "task.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080031#include "utils/dbus_utils.hpp"
32#include "utils/time_utils.hpp"
Ed Tanous1da66f72018-07-27 16:13:37 -070033
Jason M. Billse1f26342018-07-18 12:12:00 -070034#include <systemd/sd-journal.h>
Asmitha Karunanithi8e317782020-12-10 03:35:05 -060035#include <tinyxml2.h>
Adriana Kobylak400fd1f2021-01-29 09:01:30 -060036#include <unistd.h>
Jason M. Billse1f26342018-07-18 12:12:00 -070037
Ed Tanous9896eae2022-07-23 15:07:33 -070038#include <boost/algorithm/string/case_conv.hpp>
Ed Tanous11ba3972022-07-11 09:50:41 -070039#include <boost/algorithm/string/classification.hpp>
Adriana Kobylak400fd1f2021-01-29 09:01:30 -060040#include <boost/algorithm/string/replace.hpp>
Jason M. Bills4851d452019-03-28 11:27:48 -070041#include <boost/algorithm/string/split.hpp>
Ed Tanous07c8c202022-07-11 10:08:08 -070042#include <boost/beast/http/verb.hpp>
Ed Tanous1da66f72018-07-27 16:13:37 -070043#include <boost/container/flat_map.hpp>
Jason M. Bills1ddcf012019-11-26 14:59:21 -080044#include <boost/system/linux_error.hpp>
Ed Tanousef4c65b2023-04-24 15:28:50 -070045#include <boost/url/format.hpp>
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +020046#include <sdbusplus/asio/property.hpp>
47#include <sdbusplus/unpack_properties.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050048
George Liu7a1dbc42022-12-07 16:03:22 +080049#include <array>
George Liu647b3cd2021-07-05 12:43:56 +080050#include <charconv>
James Feist4418c7f2019-04-15 11:09:15 -070051#include <filesystem>
Xiaochao Ma75710de2021-01-21 17:56:02 +080052#include <optional>
Ed Tanous26702d02021-11-03 15:02:33 -070053#include <span>
Jason M. Billscd225da2019-05-08 15:31:57 -070054#include <string_view>
Ed Tanousabf2add2019-01-22 16:40:12 -080055#include <variant>
Ed Tanous1da66f72018-07-27 16:13:37 -070056
57namespace redfish
58{
59
Patrick Williams89492a12023-05-10 07:51:34 -050060constexpr const char* crashdumpObject = "com.intel.crashdump";
61constexpr const char* crashdumpPath = "/com/intel/crashdump";
62constexpr const char* crashdumpInterface = "com.intel.crashdump";
63constexpr const char* deleteAllInterface =
Jason M. Bills5b61b5e2019-10-16 10:59:02 -070064 "xyz.openbmc_project.Collection.DeleteAll";
Patrick Williams89492a12023-05-10 07:51:34 -050065constexpr const char* crashdumpOnDemandInterface =
Jason M. Bills424c4172019-03-21 13:50:33 -070066 "com.intel.crashdump.OnDemand";
Patrick Williams89492a12023-05-10 07:51:34 -050067constexpr const char* crashdumpTelemetryInterface =
Kenny L. Ku6eda7682020-06-19 09:48:36 -070068 "com.intel.crashdump.Telemetry";
Ed Tanous1da66f72018-07-27 16:13:37 -070069
Asmitha Karunanithi8e317782020-12-10 03:35:05 -060070enum class DumpCreationProgress
71{
72 DUMP_CREATE_SUCCESS,
73 DUMP_CREATE_FAILED,
74 DUMP_CREATE_INPROGRESS
75};
76
James Feistf6150402019-01-08 10:36:20 -080077namespace fs = std::filesystem;
Ed Tanous1da66f72018-07-27 16:13:37 -070078
Gunnar Mills1214b7e2020-06-04 10:11:30 -050079inline std::string translateSeverityDbusToRedfish(const std::string& s)
Andrew Geisslercb92c032018-08-17 07:56:14 -070080{
Ed Tanousd4d25792020-09-29 15:15:03 -070081 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Alert") ||
82 (s == "xyz.openbmc_project.Logging.Entry.Level.Critical") ||
83 (s == "xyz.openbmc_project.Logging.Entry.Level.Emergency") ||
84 (s == "xyz.openbmc_project.Logging.Entry.Level.Error"))
Andrew Geisslercb92c032018-08-17 07:56:14 -070085 {
86 return "Critical";
87 }
Ed Tanous3174e4d2020-10-07 11:41:22 -070088 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Debug") ||
89 (s == "xyz.openbmc_project.Logging.Entry.Level.Informational") ||
90 (s == "xyz.openbmc_project.Logging.Entry.Level.Notice"))
Andrew Geisslercb92c032018-08-17 07:56:14 -070091 {
92 return "OK";
93 }
Ed Tanous3174e4d2020-10-07 11:41:22 -070094 if (s == "xyz.openbmc_project.Logging.Entry.Level.Warning")
Andrew Geisslercb92c032018-08-17 07:56:14 -070095 {
96 return "Warning";
97 }
98 return "";
99}
100
Abhishek Patel9017faf2021-09-14 22:48:55 -0500101inline std::optional<bool> getProviderNotifyAction(const std::string& notify)
102{
103 std::optional<bool> notifyAction;
104 if (notify == "xyz.openbmc_project.Logging.Entry.Notify.Notify")
105 {
106 notifyAction = true;
107 }
108 else if (notify == "xyz.openbmc_project.Logging.Entry.Notify.Inhibit")
109 {
110 notifyAction = false;
111 }
112
113 return notifyAction;
114}
115
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700116inline static int getJournalMetadata(sd_journal* journal,
Ed Tanous26ccae32023-02-16 10:28:44 -0800117 std::string_view field,
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700118 std::string_view& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700119{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500120 const char* data = nullptr;
Jason M. Bills16428a12018-11-02 12:42:29 -0700121 size_t length = 0;
122 int ret = 0;
123 // Get the metadata from the requested field of the journal entry
Ed Tanous46ff87b2022-01-07 09:25:51 -0800124 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
125 const void** dataVoid = reinterpret_cast<const void**>(&data);
126
127 ret = sd_journal_get_data(journal, field.data(), dataVoid, &length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700128 if (ret < 0)
129 {
130 return ret;
131 }
Ed Tanous39e77502019-03-04 17:35:53 -0800132 contents = std::string_view(data, length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700133 // Only use the content after the "=" character.
Ed Tanous81ce6092020-12-17 16:54:55 +0000134 contents.remove_prefix(std::min(contents.find('=') + 1, contents.size()));
Jason M. Bills16428a12018-11-02 12:42:29 -0700135 return ret;
136}
137
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700138inline static int getJournalMetadata(sd_journal* journal,
Ed Tanous26ccae32023-02-16 10:28:44 -0800139 std::string_view field, const int& base,
140 long int& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700141{
142 int ret = 0;
Ed Tanous39e77502019-03-04 17:35:53 -0800143 std::string_view metadata;
Jason M. Bills16428a12018-11-02 12:42:29 -0700144 // Get the metadata from the requested field of the journal entry
145 ret = getJournalMetadata(journal, field, metadata);
146 if (ret < 0)
147 {
148 return ret;
149 }
Ed Tanousb01bf292019-03-25 19:25:26 +0000150 contents = strtol(metadata.data(), nullptr, base);
Jason M. Bills16428a12018-11-02 12:42:29 -0700151 return ret;
152}
153
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700154inline static bool getEntryTimestamp(sd_journal* journal,
155 std::string& entryTimestamp)
ZhikuiRena3316fc2020-01-29 14:58:08 -0800156{
157 int ret = 0;
158 uint64_t timestamp = 0;
159 ret = sd_journal_get_realtime_usec(journal, &timestamp);
160 if (ret < 0)
161 {
162 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
163 << strerror(-ret);
164 return false;
165 }
Konstantin Aladysheve645c5e2023-02-17 13:09:53 +0300166 entryTimestamp = redfish::time_utils::getDateTimeUintUs(timestamp);
Asmitha Karunanithi9c620e22020-08-02 11:55:21 -0500167 return true;
ZhikuiRena3316fc2020-01-29 14:58:08 -0800168}
Ed Tanous50b8a432022-02-03 16:29:50 -0800169
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700170inline static bool getUniqueEntryID(sd_journal* journal, std::string& entryID,
171 const bool firstEntry = true)
Jason M. Bills16428a12018-11-02 12:42:29 -0700172{
173 int ret = 0;
174 static uint64_t prevTs = 0;
175 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700176 if (firstEntry)
177 {
178 prevTs = 0;
179 }
180
Jason M. Bills16428a12018-11-02 12:42:29 -0700181 // Get the entry timestamp
182 uint64_t curTs = 0;
183 ret = sd_journal_get_realtime_usec(journal, &curTs);
184 if (ret < 0)
185 {
186 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
187 << strerror(-ret);
188 return false;
189 }
190 // If the timestamp isn't unique, increment the index
191 if (curTs == prevTs)
192 {
193 index++;
194 }
195 else
196 {
197 // Otherwise, reset it
198 index = 0;
199 }
200 // Save the timestamp
201 prevTs = curTs;
202
203 entryID = std::to_string(curTs);
204 if (index > 0)
205 {
206 entryID += "_" + std::to_string(index);
207 }
208 return true;
209}
210
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500211static bool getUniqueEntryID(const std::string& logEntry, std::string& entryID,
Jason M. Billse85d6b12019-07-29 17:01:15 -0700212 const bool firstEntry = true)
Jason M. Bills95820182019-04-22 16:25:34 -0700213{
Ed Tanous271584a2019-07-09 16:24:22 -0700214 static time_t prevTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700215 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700216 if (firstEntry)
217 {
218 prevTs = 0;
219 }
220
Jason M. Bills95820182019-04-22 16:25:34 -0700221 // Get the entry timestamp
Ed Tanous271584a2019-07-09 16:24:22 -0700222 std::time_t curTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700223 std::tm timeStruct = {};
224 std::istringstream entryStream(logEntry);
225 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
226 {
227 curTs = std::mktime(&timeStruct);
228 }
229 // If the timestamp isn't unique, increment the index
230 if (curTs == prevTs)
231 {
232 index++;
233 }
234 else
235 {
236 // Otherwise, reset it
237 index = 0;
238 }
239 // Save the timestamp
240 prevTs = curTs;
241
242 entryID = std::to_string(curTs);
243 if (index > 0)
244 {
245 entryID += "_" + std::to_string(index);
246 }
247 return true;
248}
249
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700250inline static bool
zhanghch058d1b46d2021-04-01 11:18:24 +0800251 getTimestampFromID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
252 const std::string& entryID, uint64_t& timestamp,
253 uint64_t& index)
Jason M. Bills16428a12018-11-02 12:42:29 -0700254{
255 if (entryID.empty())
256 {
257 return false;
258 }
259 // Convert the unique ID back to a timestamp to find the entry
Ed Tanous39e77502019-03-04 17:35:53 -0800260 std::string_view tsStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700261
Ed Tanous81ce6092020-12-17 16:54:55 +0000262 auto underscorePos = tsStr.find('_');
Ed Tanous71d5d8d2022-01-25 11:04:33 -0800263 if (underscorePos != std::string_view::npos)
Jason M. Bills16428a12018-11-02 12:42:29 -0700264 {
265 // Timestamp has an index
266 tsStr.remove_suffix(tsStr.size() - underscorePos);
Ed Tanous39e77502019-03-04 17:35:53 -0800267 std::string_view indexStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700268 indexStr.remove_prefix(underscorePos + 1);
Patrick Williams84396af2023-05-11 11:47:45 -0500269 auto [ptr, ec] = std::from_chars(indexStr.begin(), indexStr.end(),
270 index);
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700271 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700272 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +0800273 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700274 return false;
275 }
276 }
277 // Timestamp has no index
Patrick Williams84396af2023-05-11 11:47:45 -0500278 auto [ptr, ec] = std::from_chars(tsStr.begin(), tsStr.end(), timestamp);
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700279 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700280 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +0800281 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700282 return false;
283 }
284 return true;
285}
286
Jason M. Bills95820182019-04-22 16:25:34 -0700287static bool
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500288 getRedfishLogFiles(std::vector<std::filesystem::path>& redfishLogFiles)
Jason M. Bills95820182019-04-22 16:25:34 -0700289{
290 static const std::filesystem::path redfishLogDir = "/var/log";
291 static const std::string redfishLogFilename = "redfish";
292
293 // Loop through the directory looking for redfish log files
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500294 for (const std::filesystem::directory_entry& dirEnt :
Jason M. Bills95820182019-04-22 16:25:34 -0700295 std::filesystem::directory_iterator(redfishLogDir))
296 {
297 // If we find a redfish log file, save the path
298 std::string filename = dirEnt.path().filename();
Ed Tanous11ba3972022-07-11 09:50:41 -0700299 if (filename.starts_with(redfishLogFilename))
Jason M. Bills95820182019-04-22 16:25:34 -0700300 {
301 redfishLogFiles.emplace_back(redfishLogDir / filename);
302 }
303 }
304 // As the log files rotate, they are appended with a ".#" that is higher for
305 // the older logs. Since we don't expect more than 10 log files, we
306 // can just sort the list to get them in order from newest to oldest
307 std::sort(redfishLogFiles.begin(), redfishLogFiles.end());
308
309 return !redfishLogFiles.empty();
310}
311
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600312inline log_entry::OriginatorTypes
313 mapDbusOriginatorTypeToRedfish(const std::string& originatorType)
314{
315 if (originatorType ==
316 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.Client")
317 {
318 return log_entry::OriginatorTypes::Client;
319 }
320 if (originatorType ==
321 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.Internal")
322 {
323 return log_entry::OriginatorTypes::Internal;
324 }
325 if (originatorType ==
326 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.SupportingService")
327 {
328 return log_entry::OriginatorTypes::SupportingService;
329 }
330 return log_entry::OriginatorTypes::Invalid;
331}
332
Claire Weinanaefe3782022-07-15 19:17:19 -0700333inline void parseDumpEntryFromDbusObject(
Jiaqing Zhao2d613eb2022-08-15 16:03:00 +0800334 const dbus::utility::ManagedObjectType::value_type& object,
Claire Weinanc6fecda2022-07-15 10:43:25 -0700335 std::string& dumpStatus, uint64_t& size, uint64_t& timestampUs,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600336 std::string& originatorId, log_entry::OriginatorTypes& originatorType,
Claire Weinanaefe3782022-07-15 19:17:19 -0700337 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
338{
339 for (const auto& interfaceMap : object.second)
340 {
341 if (interfaceMap.first == "xyz.openbmc_project.Common.Progress")
342 {
343 for (const auto& propertyMap : interfaceMap.second)
344 {
345 if (propertyMap.first == "Status")
346 {
347 const auto* status =
348 std::get_if<std::string>(&propertyMap.second);
349 if (status == nullptr)
350 {
351 messages::internalError(asyncResp->res);
352 break;
353 }
354 dumpStatus = *status;
355 }
356 }
357 }
358 else if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
359 {
360 for (const auto& propertyMap : interfaceMap.second)
361 {
362 if (propertyMap.first == "Size")
363 {
364 const auto* sizePtr =
365 std::get_if<uint64_t>(&propertyMap.second);
366 if (sizePtr == nullptr)
367 {
368 messages::internalError(asyncResp->res);
369 break;
370 }
371 size = *sizePtr;
372 break;
373 }
374 }
375 }
376 else if (interfaceMap.first == "xyz.openbmc_project.Time.EpochTime")
377 {
378 for (const auto& propertyMap : interfaceMap.second)
379 {
380 if (propertyMap.first == "Elapsed")
381 {
382 const uint64_t* usecsTimeStamp =
383 std::get_if<uint64_t>(&propertyMap.second);
384 if (usecsTimeStamp == nullptr)
385 {
386 messages::internalError(asyncResp->res);
387 break;
388 }
Claire Weinanc6fecda2022-07-15 10:43:25 -0700389 timestampUs = *usecsTimeStamp;
Claire Weinanaefe3782022-07-15 19:17:19 -0700390 break;
391 }
392 }
393 }
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600394 else if (interfaceMap.first ==
395 "xyz.openbmc_project.Common.OriginatedBy")
396 {
397 for (const auto& propertyMap : interfaceMap.second)
398 {
399 if (propertyMap.first == "OriginatorId")
400 {
401 const std::string* id =
402 std::get_if<std::string>(&propertyMap.second);
403 if (id == nullptr)
404 {
405 messages::internalError(asyncResp->res);
406 break;
407 }
408 originatorId = *id;
409 }
410
411 if (propertyMap.first == "OriginatorType")
412 {
413 const std::string* type =
414 std::get_if<std::string>(&propertyMap.second);
415 if (type == nullptr)
416 {
417 messages::internalError(asyncResp->res);
418 break;
419 }
420
421 originatorType = mapDbusOriginatorTypeToRedfish(*type);
422 if (originatorType == log_entry::OriginatorTypes::Invalid)
423 {
424 messages::internalError(asyncResp->res);
425 break;
426 }
427 }
428 }
429 }
Claire Weinanaefe3782022-07-15 19:17:19 -0700430 }
431}
432
Nan Zhou21ab4042022-06-26 23:07:40 +0000433static std::string getDumpEntriesPath(const std::string& dumpType)
Claire Weinanfdd26902022-03-01 14:18:25 -0800434{
435 std::string entriesPath;
436
437 if (dumpType == "BMC")
438 {
439 entriesPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
440 }
441 else if (dumpType == "FaultLog")
442 {
443 entriesPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/";
444 }
445 else if (dumpType == "System")
446 {
447 entriesPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
448 }
449 else
450 {
451 BMCWEB_LOG_ERROR << "getDumpEntriesPath() invalid dump type: "
452 << dumpType;
453 }
454
455 // Returns empty string on error
456 return entriesPath;
457}
458
zhanghch058d1b46d2021-04-01 11:18:24 +0800459inline void
460 getDumpEntryCollection(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
461 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500462{
Claire Weinanfdd26902022-03-01 14:18:25 -0800463 std::string entriesPath = getDumpEntriesPath(dumpType);
464 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500465 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500466 messages::internalError(asyncResp->res);
467 return;
468 }
469
George Liu5eb468d2023-06-20 17:03:24 +0800470 sdbusplus::message::object_path path("/xyz/openbmc_project/dump");
471 dbus::utility::getManagedObjects(
472 "xyz.openbmc_project.Dump.Manager", path,
Claire Weinanfdd26902022-03-01 14:18:25 -0800473 [asyncResp, entriesPath,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800474 dumpType](const boost::system::error_code& ec,
George Liu5eb468d2023-06-20 17:03:24 +0800475 const dbus::utility::ManagedObjectType& objects) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700476 if (ec)
477 {
478 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
479 messages::internalError(asyncResp->res);
480 return;
481 }
482
Claire Weinanfdd26902022-03-01 14:18:25 -0800483 // Remove ending slash
484 std::string odataIdStr = entriesPath;
485 if (!odataIdStr.empty())
486 {
487 odataIdStr.pop_back();
488 }
489
490 asyncResp->res.jsonValue["@odata.type"] =
491 "#LogEntryCollection.LogEntryCollection";
492 asyncResp->res.jsonValue["@odata.id"] = std::move(odataIdStr);
493 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entries";
Patrick Williams89492a12023-05-10 07:51:34 -0500494 asyncResp->res.jsonValue["Description"] = "Collection of " + dumpType +
495 " Dump Entries";
Claire Weinanfdd26902022-03-01 14:18:25 -0800496
Ed Tanous002d39b2022-05-31 08:59:27 -0700497 nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
498 entriesArray = nlohmann::json::array();
499 std::string dumpEntryPath =
500 "/xyz/openbmc_project/dump/" +
501 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
502
George Liu5eb468d2023-06-20 17:03:24 +0800503 dbus::utility::ManagedObjectType resp(objects);
Ed Tanous002d39b2022-05-31 08:59:27 -0700504 std::sort(resp.begin(), resp.end(), [](const auto& l, const auto& r) {
505 return AlphanumLess<std::string>()(l.first.filename(),
506 r.first.filename());
507 });
508
509 for (auto& object : resp)
510 {
511 if (object.first.str.find(dumpEntryPath) == std::string::npos)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500512 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700513 continue;
514 }
Claire Weinanc6fecda2022-07-15 10:43:25 -0700515 uint64_t timestampUs = 0;
Ed Tanous002d39b2022-05-31 08:59:27 -0700516 uint64_t size = 0;
517 std::string dumpStatus;
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600518 std::string originatorId;
519 log_entry::OriginatorTypes originatorType =
520 log_entry::OriginatorTypes::Internal;
Jason M. Bills433b68b2022-06-28 12:24:26 -0700521 nlohmann::json::object_t thisEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -0700522
523 std::string entryID = object.first.filename();
524 if (entryID.empty())
525 {
526 continue;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500527 }
528
Claire Weinanc6fecda2022-07-15 10:43:25 -0700529 parseDumpEntryFromDbusObject(object, dumpStatus, size, timestampUs,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600530 originatorId, originatorType,
Claire Weinanaefe3782022-07-15 19:17:19 -0700531 asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -0700532
533 if (dumpStatus !=
534 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
535 !dumpStatus.empty())
536 {
537 // Dump status is not Complete, no need to enumerate
538 continue;
539 }
540
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600541 thisEntry["@odata.type"] = "#LogEntry.v1_11_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800542 thisEntry["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700543 thisEntry["Id"] = entryID;
544 thisEntry["EntryType"] = "Event";
Ed Tanous002d39b2022-05-31 08:59:27 -0700545 thisEntry["Name"] = dumpType + " Dump Entry";
Claire Weinanbbd80db2022-10-26 16:55:52 -0700546 thisEntry["Created"] =
547 redfish::time_utils::getDateTimeUintUs(timestampUs);
Ed Tanous002d39b2022-05-31 08:59:27 -0700548
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600549 if (!originatorId.empty())
550 {
551 thisEntry["Originator"] = originatorId;
552 thisEntry["OriginatorType"] = originatorType;
553 }
554
Ed Tanous002d39b2022-05-31 08:59:27 -0700555 if (dumpType == "BMC")
556 {
557 thisEntry["DiagnosticDataType"] = "Manager";
Patrick Williams89492a12023-05-10 07:51:34 -0500558 thisEntry["AdditionalDataURI"] = entriesPath + entryID +
559 "/attachment";
Claire Weinanfdd26902022-03-01 14:18:25 -0800560 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700561 }
562 else if (dumpType == "System")
563 {
564 thisEntry["DiagnosticDataType"] = "OEM";
565 thisEntry["OEMDiagnosticDataType"] = "System";
Patrick Williams89492a12023-05-10 07:51:34 -0500566 thisEntry["AdditionalDataURI"] = entriesPath + entryID +
567 "/attachment";
Claire Weinanfdd26902022-03-01 14:18:25 -0800568 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700569 }
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500570 entriesArray.emplace_back(std::move(thisEntry));
Ed Tanous002d39b2022-05-31 08:59:27 -0700571 }
572 asyncResp->res.jsonValue["Members@odata.count"] = entriesArray.size();
George Liu5eb468d2023-06-20 17:03:24 +0800573 });
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500574}
575
zhanghch058d1b46d2021-04-01 11:18:24 +0800576inline void
Claire Weinanc7a6d662022-06-13 16:36:39 -0700577 getDumpEntryById(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
zhanghch058d1b46d2021-04-01 11:18:24 +0800578 const std::string& entryID, const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500579{
Claire Weinanfdd26902022-03-01 14:18:25 -0800580 std::string entriesPath = getDumpEntriesPath(dumpType);
581 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500582 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500583 messages::internalError(asyncResp->res);
584 return;
585 }
586
George Liu5eb468d2023-06-20 17:03:24 +0800587 sdbusplus::message::object_path path("/xyz/openbmc_project/dump");
588 dbus::utility::getManagedObjects(
589 "xyz.openbmc_project.Dump.Manager", path,
Claire Weinanfdd26902022-03-01 14:18:25 -0800590 [asyncResp, entryID, dumpType,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800591 entriesPath](const boost::system::error_code& ec,
Ed Tanous02cad962022-06-30 16:50:15 -0700592 const dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700593 if (ec)
594 {
595 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
596 messages::internalError(asyncResp->res);
597 return;
598 }
599
600 bool foundDumpEntry = false;
601 std::string dumpEntryPath =
602 "/xyz/openbmc_project/dump/" +
603 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
604
605 for (const auto& objectPath : resp)
606 {
607 if (objectPath.first.str != dumpEntryPath + entryID)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500608 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700609 continue;
610 }
611
612 foundDumpEntry = true;
Claire Weinanc6fecda2022-07-15 10:43:25 -0700613 uint64_t timestampUs = 0;
Ed Tanous002d39b2022-05-31 08:59:27 -0700614 uint64_t size = 0;
615 std::string dumpStatus;
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600616 std::string originatorId;
617 log_entry::OriginatorTypes originatorType =
618 log_entry::OriginatorTypes::Internal;
Ed Tanous002d39b2022-05-31 08:59:27 -0700619
Claire Weinanaefe3782022-07-15 19:17:19 -0700620 parseDumpEntryFromDbusObject(objectPath, dumpStatus, size,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600621 timestampUs, originatorId,
622 originatorType, asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -0700623
624 if (dumpStatus !=
625 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
626 !dumpStatus.empty())
627 {
628 // Dump status is not Complete
629 // return not found until status is changed to Completed
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +0200630 messages::resourceNotFound(asyncResp->res, dumpType + " dump",
631 entryID);
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500632 return;
633 }
634
Ed Tanous002d39b2022-05-31 08:59:27 -0700635 asyncResp->res.jsonValue["@odata.type"] =
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600636 "#LogEntry.v1_11_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800637 asyncResp->res.jsonValue["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700638 asyncResp->res.jsonValue["Id"] = entryID;
639 asyncResp->res.jsonValue["EntryType"] = "Event";
Ed Tanous002d39b2022-05-31 08:59:27 -0700640 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entry";
Claire Weinanbbd80db2022-10-26 16:55:52 -0700641 asyncResp->res.jsonValue["Created"] =
642 redfish::time_utils::getDateTimeUintUs(timestampUs);
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500643
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600644 if (!originatorId.empty())
645 {
646 asyncResp->res.jsonValue["Originator"] = originatorId;
647 asyncResp->res.jsonValue["OriginatorType"] = originatorType;
648 }
649
Ed Tanous002d39b2022-05-31 08:59:27 -0700650 if (dumpType == "BMC")
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500651 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700652 asyncResp->res.jsonValue["DiagnosticDataType"] = "Manager";
653 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800654 entriesPath + entryID + "/attachment";
655 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500656 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700657 else if (dumpType == "System")
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500658 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700659 asyncResp->res.jsonValue["DiagnosticDataType"] = "OEM";
660 asyncResp->res.jsonValue["OEMDiagnosticDataType"] = "System";
661 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800662 entriesPath + entryID + "/attachment";
663 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500664 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700665 }
666 if (!foundDumpEntry)
667 {
Myung Baeb90d14f2023-05-31 14:40:39 -0500668 BMCWEB_LOG_WARNING << "Can't find Dump Entry " << entryID;
669 messages::resourceNotFound(asyncResp->res, dumpType + " dump",
670 entryID);
Ed Tanous002d39b2022-05-31 08:59:27 -0700671 return;
672 }
George Liu5eb468d2023-06-20 17:03:24 +0800673 });
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500674}
675
zhanghch058d1b46d2021-04-01 11:18:24 +0800676inline void deleteDumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Stanley Chu98782562020-11-04 16:10:24 +0800677 const std::string& entryID,
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500678 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500679{
Ed Tanous002d39b2022-05-31 08:59:27 -0700680 auto respHandler =
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800681 [asyncResp, entryID](const boost::system::error_code& ec) {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500682 BMCWEB_LOG_DEBUG << "Dump Entry doDelete callback: Done";
683 if (ec)
684 {
George Liu3de8d8b2021-03-22 17:49:39 +0800685 if (ec.value() == EBADR)
686 {
687 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
688 return;
689 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500690 BMCWEB_LOG_ERROR << "Dump (DBus) doDelete respHandler got error "
Claire Weinanfdd26902022-03-01 14:18:25 -0800691 << ec << " entryID=" << entryID;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500692 messages::internalError(asyncResp->res);
693 return;
694 }
695 };
696 crow::connections::systemBus->async_method_call(
697 respHandler, "xyz.openbmc_project.Dump.Manager",
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500698 "/xyz/openbmc_project/dump/" +
699 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/" +
700 entryID,
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500701 "xyz.openbmc_project.Object.Delete", "Delete");
702}
703
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600704inline DumpCreationProgress
705 mapDbusStatusToDumpProgress(const std::string& status)
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500706{
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600707 if (status ==
708 "xyz.openbmc_project.Common.Progress.OperationStatus.Failed" ||
709 status == "xyz.openbmc_project.Common.Progress.OperationStatus.Aborted")
710 {
711 return DumpCreationProgress::DUMP_CREATE_FAILED;
712 }
713 if (status ==
714 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed")
715 {
716 return DumpCreationProgress::DUMP_CREATE_SUCCESS;
717 }
718 return DumpCreationProgress::DUMP_CREATE_INPROGRESS;
719}
720
721inline DumpCreationProgress
722 getDumpCompletionStatus(const dbus::utility::DBusPropertiesMap& values)
723{
724 for (const auto& [key, val] : values)
725 {
726 if (key == "Status")
Ed Tanous002d39b2022-05-31 08:59:27 -0700727 {
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600728 const std::string* value = std::get_if<std::string>(&val);
729 if (value == nullptr)
730 {
731 BMCWEB_LOG_ERROR << "Status property value is null";
732 return DumpCreationProgress::DUMP_CREATE_FAILED;
733 }
734 return mapDbusStatusToDumpProgress(*value);
735 }
736 }
737 return DumpCreationProgress::DUMP_CREATE_INPROGRESS;
738}
739
740inline std::string getDumpEntryPath(const std::string& dumpPath)
741{
742 if (dumpPath == "/xyz/openbmc_project/dump/bmc/entry")
743 {
744 return "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
745 }
746 if (dumpPath == "/xyz/openbmc_project/dump/system/entry")
747 {
748 return "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
749 }
750 return "";
751}
752
753inline void createDumpTaskCallback(
754 task::Payload&& payload,
755 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
756 const sdbusplus::message::object_path& createdObjPath)
757{
758 const std::string dumpPath = createdObjPath.parent_path().str;
759 const std::string dumpId = createdObjPath.filename();
760
761 std::string dumpEntryPath = getDumpEntryPath(dumpPath);
762
763 if (dumpEntryPath.empty())
764 {
765 BMCWEB_LOG_ERROR << "Invalid dump type received";
766 messages::internalError(asyncResp->res);
767 return;
768 }
769
770 crow::connections::systemBus->async_method_call(
771 [asyncResp, payload, createdObjPath,
772 dumpEntryPath{std::move(dumpEntryPath)},
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800773 dumpId](const boost::system::error_code& ec,
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600774 const std::string& introspectXml) {
775 if (ec)
776 {
777 BMCWEB_LOG_ERROR << "Introspect call failed with error: "
778 << ec.message();
779 messages::internalError(asyncResp->res);
780 return;
Ed Tanous002d39b2022-05-31 08:59:27 -0700781 }
782
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600783 // Check if the created dump object has implemented Progress
784 // interface to track dump completion. If yes, fetch the "Status"
785 // property of the interface, modify the task state accordingly.
786 // Else, return task completed.
787 tinyxml2::XMLDocument doc;
Ed Tanous002d39b2022-05-31 08:59:27 -0700788
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600789 doc.Parse(introspectXml.data(), introspectXml.size());
790 tinyxml2::XMLNode* pRoot = doc.FirstChildElement("node");
791 if (pRoot == nullptr)
Ed Tanous002d39b2022-05-31 08:59:27 -0700792 {
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600793 BMCWEB_LOG_ERROR << "XML document failed to parse";
794 messages::internalError(asyncResp->res);
795 return;
796 }
797 tinyxml2::XMLElement* interfaceNode =
798 pRoot->FirstChildElement("interface");
799
800 bool isProgressIntfPresent = false;
801 while (interfaceNode != nullptr)
802 {
803 const char* thisInterfaceName = interfaceNode->Attribute("name");
804 if (thisInterfaceName != nullptr)
805 {
806 if (thisInterfaceName ==
807 std::string_view("xyz.openbmc_project.Common.Progress"))
808 {
809 interfaceNode =
810 interfaceNode->NextSiblingElement("interface");
811 continue;
812 }
813 isProgressIntfPresent = true;
814 break;
815 }
816 interfaceNode = interfaceNode->NextSiblingElement("interface");
817 }
818
819 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
820 [createdObjPath, dumpEntryPath, dumpId, isProgressIntfPresent](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800821 const boost::system::error_code& err, sdbusplus::message_t& msg,
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600822 const std::shared_ptr<task::TaskData>& taskData) {
823 if (err)
824 {
825 BMCWEB_LOG_ERROR << createdObjPath.str
826 << ": Error in creating dump";
827 taskData->messages.emplace_back(messages::internalError());
828 taskData->state = "Cancelled";
829 return task::completed;
830 }
831
832 if (isProgressIntfPresent)
833 {
834 dbus::utility::DBusPropertiesMap values;
835 std::string prop;
836 msg.read(prop, values);
837
838 DumpCreationProgress dumpStatus =
839 getDumpCompletionStatus(values);
840 if (dumpStatus == DumpCreationProgress::DUMP_CREATE_FAILED)
841 {
842 BMCWEB_LOG_ERROR << createdObjPath.str
843 << ": Error in creating dump";
844 taskData->state = "Cancelled";
845 return task::completed;
846 }
847
848 if (dumpStatus == DumpCreationProgress::DUMP_CREATE_INPROGRESS)
849 {
850 BMCWEB_LOG_DEBUG << createdObjPath.str
851 << ": Dump creation task is in progress";
852 return !task::completed;
853 }
854 }
855
Ed Tanous002d39b2022-05-31 08:59:27 -0700856 nlohmann::json retMessage = messages::success();
857 taskData->messages.emplace_back(retMessage);
858
Ed Tanousc51a58e2023-03-27 14:43:19 -0700859 boost::urls::url url = boost::urls::format(
860 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/{}", dumpId);
861
862 std::string headerLoc = "Location: ";
863 headerLoc += url.buffer();
864
Ed Tanous002d39b2022-05-31 08:59:27 -0700865 taskData->payload->httpHeaders.emplace_back(std::move(headerLoc));
866
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600867 BMCWEB_LOG_DEBUG << createdObjPath.str
868 << ": Dump creation task completed";
Ed Tanous002d39b2022-05-31 08:59:27 -0700869 taskData->state = "Completed";
870 return task::completed;
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600871 },
872 "type='signal',interface='org.freedesktop.DBus.Properties',"
873 "member='PropertiesChanged',path='" +
874 createdObjPath.str + "'");
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500875
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600876 // The task timer is set to max time limit within which the
877 // requested dump will be collected.
878 task->startTimer(std::chrono::minutes(6));
879 task->populateResp(asyncResp->res);
880 task->payload.emplace(payload);
881 },
882 "xyz.openbmc_project.Dump.Manager", createdObjPath,
883 "org.freedesktop.DBus.Introspectable", "Introspect");
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500884}
885
zhanghch058d1b46d2021-04-01 11:18:24 +0800886inline void createDump(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
887 const crow::Request& req, const std::string& dumpType)
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500888{
Claire Weinanfdd26902022-03-01 14:18:25 -0800889 std::string dumpPath = getDumpEntriesPath(dumpType);
890 if (dumpPath.empty())
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500891 {
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500892 messages::internalError(asyncResp->res);
893 return;
894 }
895
896 std::optional<std::string> diagnosticDataType;
897 std::optional<std::string> oemDiagnosticDataType;
898
Willy Tu15ed6782021-12-14 11:03:16 -0800899 if (!redfish::json_util::readJsonAction(
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500900 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
901 "OEMDiagnosticDataType", oemDiagnosticDataType))
902 {
903 return;
904 }
905
906 if (dumpType == "System")
907 {
908 if (!oemDiagnosticDataType || !diagnosticDataType)
909 {
Jason M. Bills4978b632022-02-22 14:17:43 -0800910 BMCWEB_LOG_ERROR
911 << "CreateDump action parameter 'DiagnosticDataType'/'OEMDiagnosticDataType' value not found!";
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500912 messages::actionParameterMissing(
913 asyncResp->res, "CollectDiagnosticData",
914 "DiagnosticDataType & OEMDiagnosticDataType");
915 return;
916 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700917 if ((*oemDiagnosticDataType != "System") ||
918 (*diagnosticDataType != "OEM"))
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500919 {
920 BMCWEB_LOG_ERROR << "Wrong parameter values passed";
Ed Tanousace85d62021-10-26 12:45:59 -0700921 messages::internalError(asyncResp->res);
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500922 return;
923 }
Asmitha Karunanithi59075712021-10-22 01:17:41 -0500924 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump/";
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500925 }
926 else if (dumpType == "BMC")
927 {
928 if (!diagnosticDataType)
929 {
George Liu0fda0f12021-11-16 10:06:17 +0800930 BMCWEB_LOG_ERROR
931 << "CreateDump action parameter 'DiagnosticDataType' not found!";
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500932 messages::actionParameterMissing(
933 asyncResp->res, "CollectDiagnosticData", "DiagnosticDataType");
934 return;
935 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700936 if (*diagnosticDataType != "Manager")
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500937 {
938 BMCWEB_LOG_ERROR
939 << "Wrong parameter value passed for 'DiagnosticDataType'";
Ed Tanousace85d62021-10-26 12:45:59 -0700940 messages::internalError(asyncResp->res);
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500941 return;
942 }
Asmitha Karunanithi59075712021-10-22 01:17:41 -0500943 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump/";
944 }
945 else
946 {
947 BMCWEB_LOG_ERROR << "CreateDump failed. Unknown dump type";
948 messages::internalError(asyncResp->res);
949 return;
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500950 }
951
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600952 std::vector<std::pair<std::string, std::variant<std::string, uint64_t>>>
953 createDumpParamVec;
954
Carson Labradof574a8e2023-03-22 02:26:00 +0000955 if (req.session != nullptr)
956 {
957 createDumpParamVec.emplace_back(
958 "xyz.openbmc_project.Dump.Create.CreateParameters.OriginatorId",
959 req.session->clientIp);
960 createDumpParamVec.emplace_back(
961 "xyz.openbmc_project.Dump.Create.CreateParameters.OriginatorType",
962 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.Client");
963 }
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600964
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500965 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800966 [asyncResp, payload(task::Payload(req)),
967 dumpPath](const boost::system::error_code& ec,
968 const sdbusplus::message_t& msg,
969 const sdbusplus::message::object_path& objPath) mutable {
Ed Tanous002d39b2022-05-31 08:59:27 -0700970 if (ec)
971 {
972 BMCWEB_LOG_ERROR << "CreateDump resp_handler got error " << ec;
Asmitha Karunanithi59075712021-10-22 01:17:41 -0500973 const sd_bus_error* dbusError = msg.get_error();
974 if (dbusError == nullptr)
975 {
976 messages::internalError(asyncResp->res);
977 return;
978 }
979
980 BMCWEB_LOG_ERROR << "CreateDump DBus error: " << dbusError->name
981 << " and error msg: " << dbusError->message;
982 if (std::string_view(
983 "xyz.openbmc_project.Common.Error.NotAllowed") ==
984 dbusError->name)
985 {
986 messages::resourceInStandby(asyncResp->res);
987 return;
988 }
989 if (std::string_view(
990 "xyz.openbmc_project.Dump.Create.Error.Disabled") ==
991 dbusError->name)
992 {
993 messages::serviceDisabled(asyncResp->res, dumpPath);
994 return;
995 }
996 if (std::string_view(
997 "xyz.openbmc_project.Common.Error.Unavailable") ==
998 dbusError->name)
999 {
1000 messages::resourceInUse(asyncResp->res);
1001 return;
1002 }
1003 // Other Dbus errors such as:
1004 // xyz.openbmc_project.Common.Error.InvalidArgument &
1005 // org.freedesktop.DBus.Error.InvalidArgs are all related to
1006 // the dbus call that is made here in the bmcweb
1007 // implementation and has nothing to do with the client's
1008 // input in the request. Hence, returning internal error
1009 // back to the client.
Ed Tanous002d39b2022-05-31 08:59:27 -07001010 messages::internalError(asyncResp->res);
1011 return;
1012 }
Asmitha Karunanithi8e317782020-12-10 03:35:05 -06001013 BMCWEB_LOG_DEBUG << "Dump Created. Path: " << objPath.str;
1014 createDumpTaskCallback(std::move(payload), asyncResp, objPath);
Asmitha Karunanithia43be802020-05-07 05:05:36 -05001015 },
Asmitha Karunanithib47452b2020-09-25 02:02:19 -05001016 "xyz.openbmc_project.Dump.Manager",
1017 "/xyz/openbmc_project/dump/" +
1018 std::string(boost::algorithm::to_lower_copy(dumpType)),
Asmitha Karunanithi8e317782020-12-10 03:35:05 -06001019 "xyz.openbmc_project.Dump.Create", "CreateDump", createDumpParamVec);
Asmitha Karunanithia43be802020-05-07 05:05:36 -05001020}
1021
zhanghch058d1b46d2021-04-01 11:18:24 +08001022inline void clearDump(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1023 const std::string& dumpType)
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05001024{
Asmitha Karunanithib47452b2020-09-25 02:02:19 -05001025 std::string dumpTypeLowerCopy =
1026 std::string(boost::algorithm::to_lower_copy(dumpType));
zhanghch058d1b46d2021-04-01 11:18:24 +08001027
Claire Weinan0d946212022-07-13 19:40:19 -07001028 crow::connections::systemBus->async_method_call(
1029 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001030 if (ec)
1031 {
Claire Weinan0d946212022-07-13 19:40:19 -07001032 BMCWEB_LOG_ERROR << "clearDump resp_handler got error " << ec;
Ed Tanous002d39b2022-05-31 08:59:27 -07001033 messages::internalError(asyncResp->res);
1034 return;
1035 }
Claire Weinan0d946212022-07-13 19:40:19 -07001036 },
1037 "xyz.openbmc_project.Dump.Manager",
1038 "/xyz/openbmc_project/dump/" + dumpTypeLowerCopy,
1039 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05001040}
1041
Ed Tanousb9d36b42022-02-26 21:42:46 -08001042inline static void
1043 parseCrashdumpParameters(const dbus::utility::DBusPropertiesMap& params,
1044 std::string& filename, std::string& timestamp,
1045 std::string& logfile)
Johnathan Mantey043a0532020-03-10 17:15:28 -07001046{
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001047 const std::string* filenamePtr = nullptr;
1048 const std::string* timestampPtr = nullptr;
1049 const std::string* logfilePtr = nullptr;
1050
1051 const bool success = sdbusplus::unpackPropertiesNoThrow(
1052 dbus_utils::UnpackErrorPrinter(), params, "Timestamp", timestampPtr,
1053 "Filename", filenamePtr, "Log", logfilePtr);
1054
1055 if (!success)
Johnathan Mantey043a0532020-03-10 17:15:28 -07001056 {
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001057 return;
1058 }
1059
1060 if (filenamePtr != nullptr)
1061 {
1062 filename = *filenamePtr;
1063 }
1064
1065 if (timestampPtr != nullptr)
1066 {
1067 timestamp = *timestampPtr;
1068 }
1069
1070 if (logfilePtr != nullptr)
1071 {
1072 logfile = *logfilePtr;
Johnathan Mantey043a0532020-03-10 17:15:28 -07001073 }
1074}
1075
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001076inline void requestRoutesSystemLogServiceCollection(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07001077{
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001078 /**
1079 * Functions triggers appropriate requests on DBus
1080 */
Ed Tanous22d268c2022-05-19 09:39:07 -07001081 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/")
Ed Tanoused398212021-06-09 17:05:54 -07001082 .privileges(redfish::privileges::getLogServiceCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001083 .methods(boost::beast::http::verb::get)(
1084 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001085 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1086 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001087 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001088 {
1089 return;
1090 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001091 if (systemName != "system")
1092 {
1093 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1094 systemName);
1095 return;
1096 }
1097
Ed Tanous002d39b2022-05-31 08:59:27 -07001098 // Collections don't include the static data added by SubRoute
1099 // because it has a duplicate entry for members
1100 asyncResp->res.jsonValue["@odata.type"] =
1101 "#LogServiceCollection.LogServiceCollection";
1102 asyncResp->res.jsonValue["@odata.id"] =
1103 "/redfish/v1/Systems/system/LogServices";
1104 asyncResp->res.jsonValue["Name"] = "System Log Services Collection";
1105 asyncResp->res.jsonValue["Description"] =
1106 "Collection of LogServices for this Computer System";
1107 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
1108 logServiceArray = nlohmann::json::array();
1109 nlohmann::json::object_t eventLog;
1110 eventLog["@odata.id"] =
1111 "/redfish/v1/Systems/system/LogServices/EventLog";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001112 logServiceArray.emplace_back(std::move(eventLog));
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05001113#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -07001114 nlohmann::json::object_t dumpLog;
1115 dumpLog["@odata.id"] = "/redfish/v1/Systems/system/LogServices/Dump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001116 logServiceArray.emplace_back(std::move(dumpLog));
raviteja-bc9bb6862020-02-03 11:53:32 -06001117#endif
1118
Jason M. Billsd53dd412019-02-12 17:16:22 -08001119#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -07001120 nlohmann::json::object_t crashdump;
1121 crashdump["@odata.id"] =
1122 "/redfish/v1/Systems/system/LogServices/Crashdump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001123 logServiceArray.emplace_back(std::move(crashdump));
Jason M. Billsd53dd412019-02-12 17:16:22 -08001124#endif
Spencer Kub7028eb2021-10-26 15:27:35 +08001125
1126#ifdef BMCWEB_ENABLE_REDFISH_HOST_LOGGER
Ed Tanous002d39b2022-05-31 08:59:27 -07001127 nlohmann::json::object_t hostlogger;
1128 hostlogger["@odata.id"] =
1129 "/redfish/v1/Systems/system/LogServices/HostLogger";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001130 logServiceArray.emplace_back(std::move(hostlogger));
Spencer Kub7028eb2021-10-26 15:27:35 +08001131#endif
Ed Tanous002d39b2022-05-31 08:59:27 -07001132 asyncResp->res.jsonValue["Members@odata.count"] =
1133 logServiceArray.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -08001134
George Liu7a1dbc42022-12-07 16:03:22 +08001135 constexpr std::array<std::string_view, 1> interfaces = {
1136 "xyz.openbmc_project.State.Boot.PostCode"};
1137 dbus::utility::getSubTreePaths(
1138 "/", 0, interfaces,
1139 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001140 const dbus::utility::MapperGetSubTreePathsResponse&
1141 subtreePath) {
1142 if (ec)
1143 {
1144 BMCWEB_LOG_ERROR << ec;
1145 return;
1146 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07001147
Ed Tanous002d39b2022-05-31 08:59:27 -07001148 for (const auto& pathStr : subtreePath)
1149 {
1150 if (pathStr.find("PostCode") != std::string::npos)
1151 {
1152 nlohmann::json& logServiceArrayLocal =
1153 asyncResp->res.jsonValue["Members"];
Ed Tanous613dabe2022-07-09 11:17:36 -07001154 nlohmann::json::object_t member;
1155 member["@odata.id"] =
1156 "/redfish/v1/Systems/system/LogServices/PostCodes";
1157
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001158 logServiceArrayLocal.emplace_back(std::move(member));
Ed Tanous613dabe2022-07-09 11:17:36 -07001159
Ed Tanous002d39b2022-05-31 08:59:27 -07001160 asyncResp->res.jsonValue["Members@odata.count"] =
1161 logServiceArrayLocal.size();
1162 return;
1163 }
1164 }
George Liu7a1dbc42022-12-07 16:03:22 +08001165 });
Ed Tanous45ca1b82022-03-25 13:07:27 -07001166 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001167}
1168
1169inline void requestRoutesEventLogService(App& app)
1170{
Ed Tanous22d268c2022-05-19 09:39:07 -07001171 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/")
Ed Tanoused398212021-06-09 17:05:54 -07001172 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07001173 .methods(boost::beast::http::verb::get)(
1174 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001175 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1176 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001177 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001178 {
1179 return;
1180 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001181 if (systemName != "system")
1182 {
1183 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1184 systemName);
1185 return;
1186 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001187 asyncResp->res.jsonValue["@odata.id"] =
1188 "/redfish/v1/Systems/system/LogServices/EventLog";
1189 asyncResp->res.jsonValue["@odata.type"] =
1190 "#LogService.v1_1_0.LogService";
1191 asyncResp->res.jsonValue["Name"] = "Event Log Service";
1192 asyncResp->res.jsonValue["Description"] = "System Event Log Service";
1193 asyncResp->res.jsonValue["Id"] = "EventLog";
1194 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05301195
Ed Tanous002d39b2022-05-31 08:59:27 -07001196 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07001197 redfish::time_utils::getDateTimeOffsetNow();
Tejas Patil7c8c4052021-06-04 17:43:14 +05301198
Ed Tanous002d39b2022-05-31 08:59:27 -07001199 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
1200 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
1201 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05301202
Ed Tanous002d39b2022-05-31 08:59:27 -07001203 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
1204 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1205 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001206
Ed Tanous002d39b2022-05-31 08:59:27 -07001207 {"target",
1208 "/redfish/v1/Systems/system/LogServices/EventLog/Actions/LogService.ClearLog"}};
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001209 });
1210}
1211
1212inline void requestRoutesJournalEventLogClear(App& app)
1213{
Jason M. Bills4978b632022-02-22 14:17:43 -08001214 BMCWEB_ROUTE(
1215 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07001216 "/redfish/v1/Systems/<str>/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanous432a8902021-06-14 15:28:56 -07001217 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001218 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001219 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001220 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1221 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001222 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001223 {
1224 return;
1225 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001226 if (systemName != "system")
1227 {
1228 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1229 systemName);
1230 return;
1231 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001232 // Clear the EventLog by deleting the log files
1233 std::vector<std::filesystem::path> redfishLogFiles;
1234 if (getRedfishLogFiles(redfishLogFiles))
1235 {
1236 for (const std::filesystem::path& file : redfishLogFiles)
1237 {
1238 std::error_code ec;
1239 std::filesystem::remove(file, ec);
1240 }
1241 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001242
Ed Tanous002d39b2022-05-31 08:59:27 -07001243 // Reload rsyslog so it knows to start new log files
1244 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001245 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001246 if (ec)
1247 {
1248 BMCWEB_LOG_ERROR << "Failed to reload rsyslog: " << ec;
1249 messages::internalError(asyncResp->res);
1250 return;
1251 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001252
Ed Tanous002d39b2022-05-31 08:59:27 -07001253 messages::success(asyncResp->res);
1254 },
1255 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1256 "org.freedesktop.systemd1.Manager", "ReloadUnit", "rsyslog.service",
1257 "replace");
1258 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001259}
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001260
Jason M. Billsac992cd2022-06-24 13:31:46 -07001261enum class LogParseError
1262{
1263 success,
1264 parseFailed,
1265 messageIdNotInRegistry,
1266};
1267
1268static LogParseError
1269 fillEventLogEntryJson(const std::string& logEntryID,
1270 const std::string& logEntry,
1271 nlohmann::json::object_t& logEntryJson)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001272{
Jason M. Bills95820182019-04-22 16:25:34 -07001273 // The redfish log format is "<Timestamp> <MessageId>,<MessageArgs>"
Jason M. Billscd225da2019-05-08 15:31:57 -07001274 // First get the Timestamp
Ed Tanousf23b7292020-10-15 09:41:17 -07001275 size_t space = logEntry.find_first_of(' ');
Jason M. Billscd225da2019-05-08 15:31:57 -07001276 if (space == std::string::npos)
Jason M. Bills95820182019-04-22 16:25:34 -07001277 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001278 return LogParseError::parseFailed;
Jason M. Bills95820182019-04-22 16:25:34 -07001279 }
Jason M. Billscd225da2019-05-08 15:31:57 -07001280 std::string timestamp = logEntry.substr(0, space);
1281 // Then get the log contents
Ed Tanousf23b7292020-10-15 09:41:17 -07001282 size_t entryStart = logEntry.find_first_not_of(' ', space);
Jason M. Billscd225da2019-05-08 15:31:57 -07001283 if (entryStart == std::string::npos)
1284 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001285 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001286 }
1287 std::string_view entry(logEntry);
1288 entry.remove_prefix(entryStart);
1289 // Use split to separate the entry into its fields
1290 std::vector<std::string> logEntryFields;
Ed Tanous50ebd4a2023-01-19 19:03:17 -08001291 bmcweb::split(logEntryFields, entry, ',');
Jason M. Billscd225da2019-05-08 15:31:57 -07001292 // We need at least a MessageId to be valid
Ed Tanous26f69762022-01-25 09:49:11 -08001293 if (logEntryFields.empty())
Jason M. Billscd225da2019-05-08 15:31:57 -07001294 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001295 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001296 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001297 std::string& messageID = logEntryFields[0];
Jason M. Bills95820182019-04-22 16:25:34 -07001298
Jason M. Bills4851d452019-03-28 11:27:48 -07001299 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08001300 const registries::Message* message = registries::getMessage(messageID);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001301
Sui Chen54417b02022-03-24 14:59:52 -07001302 if (message == nullptr)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001303 {
Sui Chen54417b02022-03-24 14:59:52 -07001304 BMCWEB_LOG_WARNING << "Log entry not found in registry: " << logEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001305 return LogParseError::messageIdNotInRegistry;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001306 }
1307
Sui Chen54417b02022-03-24 14:59:52 -07001308 std::string msg = message->message;
1309
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001310 // Get the MessageArgs from the log if there are any
Ed Tanous26702d02021-11-03 15:02:33 -07001311 std::span<std::string> messageArgs;
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001312 if (logEntryFields.size() > 1)
Jason M. Bills4851d452019-03-28 11:27:48 -07001313 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001314 std::string& messageArgsStart = logEntryFields[1];
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001315 // If the first string is empty, assume there are no MessageArgs
1316 std::size_t messageArgsSize = 0;
1317 if (!messageArgsStart.empty())
Jason M. Bills4851d452019-03-28 11:27:48 -07001318 {
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001319 messageArgsSize = logEntryFields.size() - 1;
1320 }
1321
Ed Tanous23a21a12020-07-25 04:45:05 +00001322 messageArgs = {&messageArgsStart, messageArgsSize};
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001323
1324 // Fill the MessageArgs into the Message
1325 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001326 for (const std::string& messageArg : messageArgs)
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001327 {
1328 std::string argStr = "%" + std::to_string(++i);
1329 size_t argPos = msg.find(argStr);
1330 if (argPos != std::string::npos)
1331 {
1332 msg.replace(argPos, argStr.length(), messageArg);
1333 }
Jason M. Bills4851d452019-03-28 11:27:48 -07001334 }
1335 }
1336
Jason M. Bills95820182019-04-22 16:25:34 -07001337 // Get the Created time from the timestamp. The log timestamp is in RFC3339
1338 // format which matches the Redfish format except for the fractional seconds
1339 // between the '.' and the '+', so just remove them.
Ed Tanousf23b7292020-10-15 09:41:17 -07001340 std::size_t dot = timestamp.find_first_of('.');
1341 std::size_t plus = timestamp.find_first_of('+');
Jason M. Bills95820182019-04-22 16:25:34 -07001342 if (dot != std::string::npos && plus != std::string::npos)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001343 {
Jason M. Bills95820182019-04-22 16:25:34 -07001344 timestamp.erase(dot, plus - dot);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001345 }
1346
1347 // Fill in the log entry with the gathered data
Vijay Lobo9c11a172021-10-07 16:53:16 -05001348 logEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001349 logEntryJson["@odata.id"] = boost::urls::format(
1350 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1351 logEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07001352 logEntryJson["Name"] = "System Event Log Entry";
1353 logEntryJson["Id"] = logEntryID;
1354 logEntryJson["Message"] = std::move(msg);
1355 logEntryJson["MessageId"] = std::move(messageID);
1356 logEntryJson["MessageArgs"] = messageArgs;
1357 logEntryJson["EntryType"] = "Event";
1358 logEntryJson["Severity"] = message->messageSeverity;
1359 logEntryJson["Created"] = std::move(timestamp);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001360 return LogParseError::success;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001361}
1362
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001363inline void requestRoutesJournalEventLogEntryCollection(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001364{
Ed Tanous22d268c2022-05-19 09:39:07 -07001365 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/")
Gunnar Mills8b6a35f2021-07-30 14:52:53 -05001366 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001367 .methods(boost::beast::http::verb::get)(
1368 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001369 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1370 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001371 query_param::QueryCapabilities capabilities = {
1372 .canDelegateTop = true,
1373 .canDelegateSkip = true,
1374 };
1375 query_param::Query delegatedQuery;
1376 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00001377 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07001378 {
1379 return;
1380 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001381 if (systemName != "system")
1382 {
1383 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1384 systemName);
1385 return;
1386 }
1387
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08001388 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07001389 size_t skip = delegatedQuery.skip.value_or(0);
1390
Ed Tanous002d39b2022-05-31 08:59:27 -07001391 // Collections don't include the static data added by SubRoute
1392 // because it has a duplicate entry for members
1393 asyncResp->res.jsonValue["@odata.type"] =
1394 "#LogEntryCollection.LogEntryCollection";
1395 asyncResp->res.jsonValue["@odata.id"] =
1396 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1397 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1398 asyncResp->res.jsonValue["Description"] =
1399 "Collection of System Event Log Entries";
1400
1401 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
1402 logEntryArray = nlohmann::json::array();
1403 // Go through the log files and create a unique ID for each
1404 // entry
1405 std::vector<std::filesystem::path> redfishLogFiles;
1406 getRedfishLogFiles(redfishLogFiles);
1407 uint64_t entryCount = 0;
1408 std::string logEntry;
1409
1410 // Oldest logs are in the last file, so start there and loop
1411 // backwards
1412 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1413 it++)
1414 {
1415 std::ifstream logStream(*it);
1416 if (!logStream.is_open())
Jason M. Bills4978b632022-02-22 14:17:43 -08001417 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001418 continue;
Jason M. Bills4978b632022-02-22 14:17:43 -08001419 }
Jason M. Bills897967d2019-07-29 17:05:30 -07001420
Ed Tanous002d39b2022-05-31 08:59:27 -07001421 // Reset the unique ID on the first entry
1422 bool firstEntry = true;
1423 while (std::getline(logStream, logEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001424 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001425 std::string idStr;
1426 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001427 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001428 continue;
1429 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001430 firstEntry = false;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001431
Jason M. Billsde703c52022-06-23 14:19:04 -07001432 nlohmann::json::object_t bmcLogEntry;
Patrick Williams89492a12023-05-10 07:51:34 -05001433 LogParseError status = fillEventLogEntryJson(idStr, logEntry,
1434 bmcLogEntry);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001435 if (status == LogParseError::messageIdNotInRegistry)
1436 {
1437 continue;
1438 }
1439 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001440 {
1441 messages::internalError(asyncResp->res);
1442 return;
Andrew Geisslercb92c032018-08-17 07:56:14 -07001443 }
Jason M. Billsde703c52022-06-23 14:19:04 -07001444
Jason M. Billsde703c52022-06-23 14:19:04 -07001445 entryCount++;
1446 // Handle paging using skip (number of entries to skip from the
1447 // start) and top (number of entries to display)
Ed Tanous3648c8b2022-07-25 13:39:59 -07001448 if (entryCount <= skip || entryCount > skip + top)
Jason M. Billsde703c52022-06-23 14:19:04 -07001449 {
1450 continue;
1451 }
1452
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001453 logEntryArray.emplace_back(std::move(bmcLogEntry));
Jason M. Bills4978b632022-02-22 14:17:43 -08001454 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001455 }
1456 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07001457 if (skip + top < entryCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07001458 {
1459 asyncResp->res.jsonValue["Members@odata.nextLink"] =
1460 "/redfish/v1/Systems/system/LogServices/EventLog/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07001461 std::to_string(skip + top);
Ed Tanous002d39b2022-05-31 08:59:27 -07001462 }
Jason M. Bills4978b632022-02-22 14:17:43 -08001463 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001464}
Chicago Duan336e96c2019-07-15 14:22:08 +08001465
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001466inline void requestRoutesJournalEventLogEntry(App& app)
1467{
1468 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001469 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001470 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001471 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001472 [&app](const crow::Request& req,
1473 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001474 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001475 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001476 {
1477 return;
1478 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001479
1480 if (systemName != "system")
1481 {
1482 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1483 systemName);
1484 return;
1485 }
1486
Ed Tanous002d39b2022-05-31 08:59:27 -07001487 const std::string& targetID = param;
1488
1489 // Go through the log files and check the unique ID for each
1490 // entry to find the target entry
1491 std::vector<std::filesystem::path> redfishLogFiles;
1492 getRedfishLogFiles(redfishLogFiles);
1493 std::string logEntry;
1494
1495 // Oldest logs are in the last file, so start there and loop
1496 // backwards
1497 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1498 it++)
1499 {
1500 std::ifstream logStream(*it);
1501 if (!logStream.is_open())
1502 {
1503 continue;
1504 }
1505
1506 // Reset the unique ID on the first entry
1507 bool firstEntry = true;
1508 while (std::getline(logStream, logEntry))
1509 {
1510 std::string idStr;
1511 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Ed Tanous45ca1b82022-03-25 13:07:27 -07001512 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001513 continue;
1514 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001515 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07001516
1517 if (idStr == targetID)
1518 {
Jason M. Billsde703c52022-06-23 14:19:04 -07001519 nlohmann::json::object_t bmcLogEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001520 LogParseError status =
1521 fillEventLogEntryJson(idStr, logEntry, bmcLogEntry);
1522 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001523 {
1524 messages::internalError(asyncResp->res);
1525 return;
1526 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07001527 asyncResp->res.jsonValue.update(bmcLogEntry);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001528 return;
1529 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001530 }
1531 }
1532 // Requested ID was not found
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08001533 messages::resourceNotFound(asyncResp->res, "LogEntry", targetID);
Ed Tanous002d39b2022-05-31 08:59:27 -07001534 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001535}
1536
1537inline void requestRoutesDBusEventLogEntryCollection(App& app)
1538{
Ed Tanous22d268c2022-05-19 09:39:07 -07001539 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07001540 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001541 .methods(boost::beast::http::verb::get)(
1542 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001543 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1544 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001545 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001546 {
1547 return;
1548 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001549 if (systemName != "system")
1550 {
1551 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1552 systemName);
1553 return;
1554 }
1555
Ed Tanous002d39b2022-05-31 08:59:27 -07001556 // Collections don't include the static data added by SubRoute
1557 // because it has a duplicate entry for members
1558 asyncResp->res.jsonValue["@odata.type"] =
1559 "#LogEntryCollection.LogEntryCollection";
1560 asyncResp->res.jsonValue["@odata.id"] =
1561 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1562 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1563 asyncResp->res.jsonValue["Description"] =
1564 "Collection of System Event Log Entries";
1565
1566 // DBus implementation of EventLog/Entries
1567 // Make call to Logging Service to find all log entry objects
George Liu5eb468d2023-06-20 17:03:24 +08001568 sdbusplus::message::object_path path("/xyz/openbmc_project/logging");
1569 dbus::utility::getManagedObjects(
1570 "xyz.openbmc_project.Logging", path,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001571 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001572 const dbus::utility::ManagedObjectType& resp) {
1573 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001574 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001575 // TODO Handle for specific error code
1576 BMCWEB_LOG_ERROR
1577 << "getLogEntriesIfaceData resp_handler got error " << ec;
1578 messages::internalError(asyncResp->res);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001579 return;
1580 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001581 nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
1582 entriesArray = nlohmann::json::array();
1583 for (const auto& objectPath : resp)
1584 {
1585 const uint32_t* id = nullptr;
1586 const uint64_t* timestamp = nullptr;
1587 const uint64_t* updateTimestamp = nullptr;
1588 const std::string* severity = nullptr;
1589 const std::string* message = nullptr;
1590 const std::string* filePath = nullptr;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001591 const std::string* resolution = nullptr;
Ed Tanous002d39b2022-05-31 08:59:27 -07001592 bool resolved = false;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001593 const std::string* notify = nullptr;
1594
Ed Tanous002d39b2022-05-31 08:59:27 -07001595 for (const auto& interfaceMap : objectPath.second)
1596 {
1597 if (interfaceMap.first ==
1598 "xyz.openbmc_project.Logging.Entry")
Xiaochao Ma75710de2021-01-21 17:56:02 +08001599 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001600 for (const auto& propertyMap : interfaceMap.second)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001601 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001602 if (propertyMap.first == "Id")
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001603 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001604 id = std::get_if<uint32_t>(&propertyMap.second);
1605 }
1606 else if (propertyMap.first == "Timestamp")
1607 {
1608 timestamp =
1609 std::get_if<uint64_t>(&propertyMap.second);
1610 }
1611 else if (propertyMap.first == "UpdateTimestamp")
1612 {
1613 updateTimestamp =
1614 std::get_if<uint64_t>(&propertyMap.second);
1615 }
1616 else if (propertyMap.first == "Severity")
1617 {
1618 severity = std::get_if<std::string>(
1619 &propertyMap.second);
1620 }
Vijay Lobo9c11a172021-10-07 16:53:16 -05001621 else if (propertyMap.first == "Resolution")
1622 {
1623 resolution = std::get_if<std::string>(
1624 &propertyMap.second);
1625 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001626 else if (propertyMap.first == "Message")
1627 {
1628 message = std::get_if<std::string>(
1629 &propertyMap.second);
1630 }
1631 else if (propertyMap.first == "Resolved")
1632 {
1633 const bool* resolveptr =
1634 std::get_if<bool>(&propertyMap.second);
1635 if (resolveptr == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001636 {
1637 messages::internalError(asyncResp->res);
1638 return;
1639 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001640 resolved = *resolveptr;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001641 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001642 else if (propertyMap.first ==
1643 "ServiceProviderNotify")
1644 {
1645 notify = std::get_if<std::string>(
1646 &propertyMap.second);
1647 if (notify == nullptr)
1648 {
1649 messages::internalError(asyncResp->res);
1650 return;
1651 }
1652 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001653 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001654 if (id == nullptr || message == nullptr ||
Ed Tanous002d39b2022-05-31 08:59:27 -07001655 severity == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001656 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001657 messages::internalError(asyncResp->res);
1658 return;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001659 }
1660 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001661 else if (interfaceMap.first ==
1662 "xyz.openbmc_project.Common.FilePath")
1663 {
1664 for (const auto& propertyMap : interfaceMap.second)
1665 {
1666 if (propertyMap.first == "Path")
1667 {
1668 filePath = std::get_if<std::string>(
1669 &propertyMap.second);
1670 }
1671 }
1672 }
1673 }
1674 // Object path without the
1675 // xyz.openbmc_project.Logging.Entry interface, ignore
1676 // and continue.
1677 if (id == nullptr || message == nullptr ||
1678 severity == nullptr || timestamp == nullptr ||
1679 updateTimestamp == nullptr)
1680 {
1681 continue;
1682 }
1683 entriesArray.push_back({});
1684 nlohmann::json& thisEntry = entriesArray.back();
Vijay Lobo9c11a172021-10-07 16:53:16 -05001685 thisEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001686 thisEntry["@odata.id"] = boost::urls::format(
1687 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1688 std::to_string(*id));
Ed Tanous002d39b2022-05-31 08:59:27 -07001689 thisEntry["Name"] = "System Event Log Entry";
1690 thisEntry["Id"] = std::to_string(*id);
1691 thisEntry["Message"] = *message;
1692 thisEntry["Resolved"] = resolved;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001693 if ((resolution != nullptr) && (!(*resolution).empty()))
1694 {
1695 thisEntry["Resolution"] = *resolution;
1696 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001697 std::optional<bool> notifyAction =
1698 getProviderNotifyAction(*notify);
1699 if (notifyAction)
1700 {
1701 thisEntry["ServiceProviderNotified"] = *notifyAction;
1702 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001703 thisEntry["EntryType"] = "Event";
1704 thisEntry["Severity"] =
1705 translateSeverityDbusToRedfish(*severity);
1706 thisEntry["Created"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001707 redfish::time_utils::getDateTimeUintMs(*timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001708 thisEntry["Modified"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001709 redfish::time_utils::getDateTimeUintMs(*updateTimestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001710 if (filePath != nullptr)
1711 {
1712 thisEntry["AdditionalDataURI"] =
1713 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1714 std::to_string(*id) + "/attachment";
1715 }
1716 }
1717 std::sort(
1718 entriesArray.begin(), entriesArray.end(),
1719 [](const nlohmann::json& left, const nlohmann::json& right) {
1720 return (left["Id"] <= right["Id"]);
1721 });
1722 asyncResp->res.jsonValue["Members@odata.count"] =
1723 entriesArray.size();
George Liu5eb468d2023-06-20 17:03:24 +08001724 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001725 });
1726}
Xiaochao Ma75710de2021-01-21 17:56:02 +08001727
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001728inline void requestRoutesDBusEventLogEntry(App& app)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001729{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001730 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001731 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001732 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07001733 .methods(boost::beast::http::verb::get)(
1734 [&app](const crow::Request& req,
1735 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001736 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001737 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001738 {
1739 return;
1740 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001741 if (systemName != "system")
1742 {
1743 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1744 systemName);
1745 return;
1746 }
1747
Ed Tanous002d39b2022-05-31 08:59:27 -07001748 std::string entryID = param;
1749 dbus::utility::escapePathForDbus(entryID);
1750
1751 // DBus implementation of EventLog/Entries
1752 // Make call to Logging Service to find all log entry objects
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001753 sdbusplus::asio::getAllProperties(
1754 *crow::connections::systemBus, "xyz.openbmc_project.Logging",
1755 "/xyz/openbmc_project/logging/entry/" + entryID, "",
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001756 [asyncResp, entryID](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001757 const dbus::utility::DBusPropertiesMap& resp) {
1758 if (ec.value() == EBADR)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001759 {
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001760 messages::resourceNotFound(asyncResp->res, "EventLogEntry",
1761 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001762 return;
1763 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001764 if (ec)
1765 {
1766 BMCWEB_LOG_ERROR
1767 << "EventLogEntry (DBus) resp_handler got error " << ec;
1768 messages::internalError(asyncResp->res);
1769 return;
1770 }
1771 const uint32_t* id = nullptr;
1772 const uint64_t* timestamp = nullptr;
1773 const uint64_t* updateTimestamp = nullptr;
1774 const std::string* severity = nullptr;
1775 const std::string* message = nullptr;
1776 const std::string* filePath = nullptr;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001777 const std::string* resolution = nullptr;
Ed Tanous002d39b2022-05-31 08:59:27 -07001778 bool resolved = false;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001779 const std::string* notify = nullptr;
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001780
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001781 const bool success = sdbusplus::unpackPropertiesNoThrow(
1782 dbus_utils::UnpackErrorPrinter(), resp, "Id", id, "Timestamp",
1783 timestamp, "UpdateTimestamp", updateTimestamp, "Severity",
Vijay Lobo9c11a172021-10-07 16:53:16 -05001784 severity, "Message", message, "Resolved", resolved,
Abhishek Patel9017faf2021-09-14 22:48:55 -05001785 "Resolution", resolution, "Path", filePath,
1786 "ServiceProviderNotify", notify);
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001787
1788 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001789 {
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001790 messages::internalError(asyncResp->res);
1791 return;
Ed Tanous002d39b2022-05-31 08:59:27 -07001792 }
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001793
Ed Tanous002d39b2022-05-31 08:59:27 -07001794 if (id == nullptr || message == nullptr || severity == nullptr ||
Abhishek Patel9017faf2021-09-14 22:48:55 -05001795 timestamp == nullptr || updateTimestamp == nullptr ||
1796 notify == nullptr)
Ed Tanous002d39b2022-05-31 08:59:27 -07001797 {
1798 messages::internalError(asyncResp->res);
1799 return;
1800 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001801
Ed Tanous002d39b2022-05-31 08:59:27 -07001802 asyncResp->res.jsonValue["@odata.type"] =
Vijay Lobo9c11a172021-10-07 16:53:16 -05001803 "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001804 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
1805 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1806 std::to_string(*id));
Ed Tanous002d39b2022-05-31 08:59:27 -07001807 asyncResp->res.jsonValue["Name"] = "System Event Log Entry";
1808 asyncResp->res.jsonValue["Id"] = std::to_string(*id);
1809 asyncResp->res.jsonValue["Message"] = *message;
1810 asyncResp->res.jsonValue["Resolved"] = resolved;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001811 std::optional<bool> notifyAction = getProviderNotifyAction(*notify);
1812 if (notifyAction)
1813 {
1814 asyncResp->res.jsonValue["ServiceProviderNotified"] =
1815 *notifyAction;
1816 }
Vijay Lobo9c11a172021-10-07 16:53:16 -05001817 if ((resolution != nullptr) && (!(*resolution).empty()))
1818 {
1819 asyncResp->res.jsonValue["Resolution"] = *resolution;
1820 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001821 asyncResp->res.jsonValue["EntryType"] = "Event";
1822 asyncResp->res.jsonValue["Severity"] =
1823 translateSeverityDbusToRedfish(*severity);
1824 asyncResp->res.jsonValue["Created"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001825 redfish::time_utils::getDateTimeUintMs(*timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001826 asyncResp->res.jsonValue["Modified"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001827 redfish::time_utils::getDateTimeUintMs(*updateTimestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001828 if (filePath != nullptr)
1829 {
1830 asyncResp->res.jsonValue["AdditionalDataURI"] =
1831 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1832 std::to_string(*id) + "/attachment";
1833 }
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001834 });
Ed Tanous45ca1b82022-03-25 13:07:27 -07001835 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001836
1837 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001838 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001839 .privileges(redfish::privileges::patchLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001840 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001841 [&app](const crow::Request& req,
1842 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001843 const std::string& systemName, const std::string& entryId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001844 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001845 {
1846 return;
1847 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001848 if (systemName != "system")
1849 {
1850 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1851 systemName);
1852 return;
1853 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001854 std::optional<bool> resolved;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001855
Ed Tanous002d39b2022-05-31 08:59:27 -07001856 if (!json_util::readJsonPatch(req, asyncResp->res, "Resolved",
1857 resolved))
1858 {
1859 return;
1860 }
1861 BMCWEB_LOG_DEBUG << "Set Resolved";
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001862
Ed Tanous002d39b2022-05-31 08:59:27 -07001863 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001864 [asyncResp, entryId](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001865 if (ec)
1866 {
1867 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1868 messages::internalError(asyncResp->res);
1869 return;
1870 }
1871 },
1872 "xyz.openbmc_project.Logging",
1873 "/xyz/openbmc_project/logging/entry/" + entryId,
1874 "org.freedesktop.DBus.Properties", "Set",
1875 "xyz.openbmc_project.Logging.Entry", "Resolved",
1876 dbus::utility::DbusVariantType(*resolved));
1877 });
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001878
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001879 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001880 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001881 .privileges(redfish::privileges::deleteLogEntry)
1882
Ed Tanous002d39b2022-05-31 08:59:27 -07001883 .methods(boost::beast::http::verb::delete_)(
1884 [&app](const crow::Request& req,
1885 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001886 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001887 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001888 {
1889 return;
1890 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001891 if (systemName != "system")
1892 {
1893 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1894 systemName);
1895 return;
1896 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001897 BMCWEB_LOG_DEBUG << "Do delete single event entries.";
1898
1899 std::string entryID = param;
1900
1901 dbus::utility::escapePathForDbus(entryID);
1902
1903 // Process response from Logging service.
1904 auto respHandler =
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001905 [asyncResp, entryID](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001906 BMCWEB_LOG_DEBUG << "EventLogEntry (DBus) doDelete callback: Done";
1907 if (ec)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001908 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001909 if (ec.value() == EBADR)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001910 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001911 messages::resourceNotFound(asyncResp->res, "LogEntry",
1912 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001913 return;
1914 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001915 // TODO Handle for specific error code
1916 BMCWEB_LOG_ERROR
1917 << "EventLogEntry (DBus) doDelete respHandler got error "
1918 << ec;
1919 asyncResp->res.result(
1920 boost::beast::http::status::internal_server_error);
1921 return;
1922 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001923
Ed Tanous002d39b2022-05-31 08:59:27 -07001924 asyncResp->res.result(boost::beast::http::status::ok);
1925 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001926
Ed Tanous002d39b2022-05-31 08:59:27 -07001927 // Make call to Logging service to request Delete Log
1928 crow::connections::systemBus->async_method_call(
1929 respHandler, "xyz.openbmc_project.Logging",
1930 "/xyz/openbmc_project/logging/entry/" + entryID,
1931 "xyz.openbmc_project.Object.Delete", "Delete");
Ed Tanous45ca1b82022-03-25 13:07:27 -07001932 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001933}
1934
1935inline void requestRoutesDBusEventLogEntryDownload(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001936{
George Liu0fda0f12021-11-16 10:06:17 +08001937 BMCWEB_ROUTE(
1938 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07001939 "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/attachment")
Ed Tanoused398212021-06-09 17:05:54 -07001940 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001941 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001942 [&app](const crow::Request& req,
1943 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001944 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001945 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001946 {
1947 return;
1948 }
Matt Spinler72e21372023-04-19 12:53:33 -05001949 if (!http_helpers::isContentTypeAllowed(
Ed Tanous99351cd2022-08-07 16:42:51 -07001950 req.getHeaderValue("Accept"),
Ed Tanous4a0e1a02022-09-21 15:28:04 -07001951 http_helpers::ContentType::OctetStream, true))
Ed Tanous002d39b2022-05-31 08:59:27 -07001952 {
1953 asyncResp->res.result(boost::beast::http::status::bad_request);
1954 return;
1955 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001956 if (systemName != "system")
1957 {
1958 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1959 systemName);
1960 return;
1961 }
zhanghch058d1b46d2021-04-01 11:18:24 +08001962
Ed Tanous002d39b2022-05-31 08:59:27 -07001963 std::string entryID = param;
1964 dbus::utility::escapePathForDbus(entryID);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001965
Ed Tanous002d39b2022-05-31 08:59:27 -07001966 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001967 [asyncResp, entryID](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001968 const sdbusplus::message::unix_fd& unixfd) {
1969 if (ec.value() == EBADR)
1970 {
1971 messages::resourceNotFound(asyncResp->res, "EventLogAttachment",
1972 entryID);
1973 return;
1974 }
1975 if (ec)
1976 {
1977 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1978 messages::internalError(asyncResp->res);
1979 return;
1980 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001981
Ed Tanous002d39b2022-05-31 08:59:27 -07001982 int fd = -1;
1983 fd = dup(unixfd);
1984 if (fd == -1)
1985 {
1986 messages::internalError(asyncResp->res);
1987 return;
1988 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001989
Ed Tanous002d39b2022-05-31 08:59:27 -07001990 long long int size = lseek(fd, 0, SEEK_END);
1991 if (size == -1)
1992 {
1993 messages::internalError(asyncResp->res);
1994 return;
1995 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001996
Ed Tanous002d39b2022-05-31 08:59:27 -07001997 // Arbitrary max size of 64kb
1998 constexpr int maxFileSize = 65536;
1999 if (size > maxFileSize)
2000 {
2001 BMCWEB_LOG_ERROR << "File size exceeds maximum allowed size of "
2002 << maxFileSize;
2003 messages::internalError(asyncResp->res);
2004 return;
2005 }
2006 std::vector<char> data(static_cast<size_t>(size));
2007 long long int rc = lseek(fd, 0, SEEK_SET);
2008 if (rc == -1)
2009 {
2010 messages::internalError(asyncResp->res);
2011 return;
2012 }
2013 rc = read(fd, data.data(), data.size());
2014 if ((rc == -1) || (rc != size))
2015 {
2016 messages::internalError(asyncResp->res);
2017 return;
2018 }
2019 close(fd);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002020
Ed Tanous002d39b2022-05-31 08:59:27 -07002021 std::string_view strData(data.data(), data.size());
2022 std::string output = crow::utility::base64encode(strData);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002023
Ed Tanousd9f6c622022-03-17 09:12:17 -07002024 asyncResp->res.addHeader(boost::beast::http::field::content_type,
Ed Tanous002d39b2022-05-31 08:59:27 -07002025 "application/octet-stream");
Ed Tanousd9f6c622022-03-17 09:12:17 -07002026 asyncResp->res.addHeader(
2027 boost::beast::http::field::content_transfer_encoding, "Base64");
Ed Tanous002d39b2022-05-31 08:59:27 -07002028 asyncResp->res.body() = std::move(output);
2029 },
2030 "xyz.openbmc_project.Logging",
2031 "/xyz/openbmc_project/logging/entry/" + entryID,
2032 "xyz.openbmc_project.Logging.Entry", "GetEntry");
2033 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002034}
2035
Spencer Kub7028eb2021-10-26 15:27:35 +08002036constexpr const char* hostLoggerFolderPath = "/var/log/console";
2037
2038inline bool
2039 getHostLoggerFiles(const std::string& hostLoggerFilePath,
2040 std::vector<std::filesystem::path>& hostLoggerFiles)
2041{
2042 std::error_code ec;
2043 std::filesystem::directory_iterator logPath(hostLoggerFilePath, ec);
2044 if (ec)
2045 {
2046 BMCWEB_LOG_ERROR << ec.message();
2047 return false;
2048 }
2049 for (const std::filesystem::directory_entry& it : logPath)
2050 {
2051 std::string filename = it.path().filename();
2052 // Prefix of each log files is "log". Find the file and save the
2053 // path
Ed Tanous11ba3972022-07-11 09:50:41 -07002054 if (filename.starts_with("log"))
Spencer Kub7028eb2021-10-26 15:27:35 +08002055 {
2056 hostLoggerFiles.emplace_back(it.path());
2057 }
2058 }
2059 // As the log files rotate, they are appended with a ".#" that is higher for
2060 // the older logs. Since we start from oldest logs, sort the name in
2061 // descending order.
2062 std::sort(hostLoggerFiles.rbegin(), hostLoggerFiles.rend(),
2063 AlphanumLess<std::string>());
2064
2065 return true;
2066}
2067
Ed Tanous02cad962022-06-30 16:50:15 -07002068inline bool getHostLoggerEntries(
2069 const std::vector<std::filesystem::path>& hostLoggerFiles, uint64_t skip,
2070 uint64_t top, std::vector<std::string>& logEntries, size_t& logCount)
Spencer Kub7028eb2021-10-26 15:27:35 +08002071{
2072 GzFileReader logFile;
2073
2074 // Go though all log files and expose host logs.
2075 for (const std::filesystem::path& it : hostLoggerFiles)
2076 {
2077 if (!logFile.gzGetLines(it.string(), skip, top, logEntries, logCount))
2078 {
2079 BMCWEB_LOG_ERROR << "fail to expose host logs";
2080 return false;
2081 }
2082 }
2083 // Get lastMessage from constructor by getter
2084 std::string lastMessage = logFile.getLastMessage();
2085 if (!lastMessage.empty())
2086 {
2087 logCount++;
2088 if (logCount > skip && logCount <= (skip + top))
2089 {
2090 logEntries.push_back(lastMessage);
2091 }
2092 }
2093 return true;
2094}
2095
2096inline void fillHostLoggerEntryJson(const std::string& logEntryID,
2097 const std::string& msg,
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002098 nlohmann::json::object_t& logEntryJson)
Spencer Kub7028eb2021-10-26 15:27:35 +08002099{
2100 // Fill in the log entry with the gathered data.
Vijay Lobo9c11a172021-10-07 16:53:16 -05002101 logEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07002102 logEntryJson["@odata.id"] = boost::urls::format(
2103 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries/{}",
2104 logEntryID);
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002105 logEntryJson["Name"] = "Host Logger Entry";
2106 logEntryJson["Id"] = logEntryID;
2107 logEntryJson["Message"] = msg;
2108 logEntryJson["EntryType"] = "Oem";
2109 logEntryJson["Severity"] = "OK";
2110 logEntryJson["OemRecordFormat"] = "Host Logger Entry";
Spencer Kub7028eb2021-10-26 15:27:35 +08002111}
2112
2113inline void requestRoutesSystemHostLogger(App& app)
2114{
Ed Tanous22d268c2022-05-19 09:39:07 -07002115 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/HostLogger/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002116 .privileges(redfish::privileges::getLogService)
Ed Tanous14766872022-03-15 10:44:42 -07002117 .methods(boost::beast::http::verb::get)(
2118 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07002119 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2120 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002121 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002122 {
2123 return;
2124 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002125 if (systemName != "system")
2126 {
2127 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2128 systemName);
2129 return;
2130 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002131 asyncResp->res.jsonValue["@odata.id"] =
2132 "/redfish/v1/Systems/system/LogServices/HostLogger";
2133 asyncResp->res.jsonValue["@odata.type"] =
2134 "#LogService.v1_1_0.LogService";
2135 asyncResp->res.jsonValue["Name"] = "Host Logger Service";
2136 asyncResp->res.jsonValue["Description"] = "Host Logger Service";
2137 asyncResp->res.jsonValue["Id"] = "HostLogger";
2138 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2139 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
2140 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002141}
2142
2143inline void requestRoutesSystemHostLoggerCollection(App& app)
2144{
2145 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07002146 "/redfish/v1/Systems/<str>/LogServices/HostLogger/Entries/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002147 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07002148 .methods(boost::beast::http::verb::get)(
2149 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07002150 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2151 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07002152 query_param::QueryCapabilities capabilities = {
2153 .canDelegateTop = true,
2154 .canDelegateSkip = true,
2155 };
2156 query_param::Query delegatedQuery;
2157 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00002158 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07002159 {
2160 return;
2161 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002162 if (systemName != "system")
2163 {
2164 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2165 systemName);
2166 return;
2167 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002168 asyncResp->res.jsonValue["@odata.id"] =
2169 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
2170 asyncResp->res.jsonValue["@odata.type"] =
2171 "#LogEntryCollection.LogEntryCollection";
2172 asyncResp->res.jsonValue["Name"] = "HostLogger Entries";
2173 asyncResp->res.jsonValue["Description"] =
2174 "Collection of HostLogger Entries";
2175 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
2176 logEntryArray = nlohmann::json::array();
2177 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Spencer Kub7028eb2021-10-26 15:27:35 +08002178
Ed Tanous002d39b2022-05-31 08:59:27 -07002179 std::vector<std::filesystem::path> hostLoggerFiles;
2180 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
2181 {
2182 BMCWEB_LOG_ERROR << "fail to get host log file path";
2183 return;
2184 }
Ed Tanous3648c8b2022-07-25 13:39:59 -07002185 // If we weren't provided top and skip limits, use the defaults.
2186 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08002187 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous002d39b2022-05-31 08:59:27 -07002188 size_t logCount = 0;
2189 // This vector only store the entries we want to expose that
2190 // control by skip and top.
2191 std::vector<std::string> logEntries;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002192 if (!getHostLoggerEntries(hostLoggerFiles, skip, top, logEntries,
2193 logCount))
Ed Tanous002d39b2022-05-31 08:59:27 -07002194 {
2195 messages::internalError(asyncResp->res);
2196 return;
2197 }
2198 // If vector is empty, that means skip value larger than total
2199 // log count
2200 if (logEntries.empty())
2201 {
2202 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
2203 return;
2204 }
2205 if (!logEntries.empty())
2206 {
2207 for (size_t i = 0; i < logEntries.size(); i++)
George Liu0fda0f12021-11-16 10:06:17 +08002208 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002209 nlohmann::json::object_t hostLogEntry;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002210 fillHostLoggerEntryJson(std::to_string(skip + i), logEntries[i],
2211 hostLogEntry);
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002212 logEntryArray.emplace_back(std::move(hostLogEntry));
George Liu0fda0f12021-11-16 10:06:17 +08002213 }
2214
Ed Tanous002d39b2022-05-31 08:59:27 -07002215 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002216 if (skip + top < logCount)
George Liu0fda0f12021-11-16 10:06:17 +08002217 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002218 asyncResp->res.jsonValue["Members@odata.nextLink"] =
2219 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07002220 std::to_string(skip + top);
George Liu0fda0f12021-11-16 10:06:17 +08002221 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002222 }
George Liu0fda0f12021-11-16 10:06:17 +08002223 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002224}
2225
2226inline void requestRoutesSystemHostLoggerLogEntry(App& app)
2227{
2228 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07002229 app, "/redfish/v1/Systems/<str>/LogServices/HostLogger/Entries/<str>/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002230 .privileges(redfish::privileges::getLogEntry)
2231 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002232 [&app](const crow::Request& req,
2233 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07002234 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002235 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002236 {
2237 return;
2238 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002239 if (systemName != "system")
2240 {
2241 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2242 systemName);
2243 return;
2244 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002245 const std::string& targetID = param;
Spencer Kub7028eb2021-10-26 15:27:35 +08002246
Ed Tanous002d39b2022-05-31 08:59:27 -07002247 uint64_t idInt = 0;
Ed Tanousca45aa32022-01-07 09:28:45 -08002248
Patrick Williams84396af2023-05-11 11:47:45 -05002249 auto [ptr, ec] = std::from_chars(&*targetID.begin(), &*targetID.end(),
2250 idInt);
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002251 if (ec == std::errc::invalid_argument ||
2252 ec == std::errc::result_out_of_range)
Ed Tanous002d39b2022-05-31 08:59:27 -07002253 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002254 messages::resourceNotFound(asyncResp->res, "LogEntry", param);
Ed Tanous002d39b2022-05-31 08:59:27 -07002255 return;
2256 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002257
Ed Tanous002d39b2022-05-31 08:59:27 -07002258 std::vector<std::filesystem::path> hostLoggerFiles;
2259 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
2260 {
2261 BMCWEB_LOG_ERROR << "fail to get host log file path";
2262 return;
2263 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002264
Ed Tanous002d39b2022-05-31 08:59:27 -07002265 size_t logCount = 0;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002266 size_t top = 1;
Ed Tanous002d39b2022-05-31 08:59:27 -07002267 std::vector<std::string> logEntries;
2268 // We can get specific entry by skip and top. For example, if we
2269 // want to get nth entry, we can set skip = n-1 and top = 1 to
2270 // get that entry
2271 if (!getHostLoggerEntries(hostLoggerFiles, idInt, top, logEntries,
2272 logCount))
2273 {
2274 messages::internalError(asyncResp->res);
2275 return;
2276 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002277
Ed Tanous002d39b2022-05-31 08:59:27 -07002278 if (!logEntries.empty())
2279 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002280 nlohmann::json::object_t hostLogEntry;
2281 fillHostLoggerEntryJson(targetID, logEntries[0], hostLogEntry);
2282 asyncResp->res.jsonValue.update(hostLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002283 return;
2284 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002285
Ed Tanous002d39b2022-05-31 08:59:27 -07002286 // Requested ID was not found
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002287 messages::resourceNotFound(asyncResp->res, "LogEntry", param);
Ed Tanous002d39b2022-05-31 08:59:27 -07002288 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002289}
2290
Claire Weinandd72e872022-08-15 14:20:06 -07002291inline void handleBMCLogServicesCollectionGet(
Claire Weinanfdd26902022-03-01 14:18:25 -08002292 crow::App& app, const crow::Request& req,
2293 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2294{
2295 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2296 {
2297 return;
2298 }
2299 // Collections don't include the static data added by SubRoute
2300 // because it has a duplicate entry for members
2301 asyncResp->res.jsonValue["@odata.type"] =
2302 "#LogServiceCollection.LogServiceCollection";
2303 asyncResp->res.jsonValue["@odata.id"] =
2304 "/redfish/v1/Managers/bmc/LogServices";
2305 asyncResp->res.jsonValue["Name"] = "Open BMC Log Services Collection";
2306 asyncResp->res.jsonValue["Description"] =
2307 "Collection of LogServices for this Manager";
2308 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
2309 logServiceArray = nlohmann::json::array();
2310
2311#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
Ed Tanous613dabe2022-07-09 11:17:36 -07002312 nlohmann::json::object_t journal;
2313 journal["@odata.id"] = "/redfish/v1/Managers/bmc/LogServices/Journal";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002314 logServiceArray.emplace_back(std::move(journal));
Claire Weinanfdd26902022-03-01 14:18:25 -08002315#endif
2316
2317 asyncResp->res.jsonValue["Members@odata.count"] = logServiceArray.size();
2318
2319#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
George Liu15912152023-01-11 10:18:18 +08002320 constexpr std::array<std::string_view, 1> interfaces = {
George Liu7a1dbc42022-12-07 16:03:22 +08002321 "xyz.openbmc_project.Collection.DeleteAll"};
2322 dbus::utility::getSubTreePaths(
2323 "/xyz/openbmc_project/dump", 0, interfaces,
Claire Weinanfdd26902022-03-01 14:18:25 -08002324 [asyncResp](
George Liu7a1dbc42022-12-07 16:03:22 +08002325 const boost::system::error_code& ec,
Claire Weinanfdd26902022-03-01 14:18:25 -08002326 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
2327 if (ec)
2328 {
2329 BMCWEB_LOG_ERROR
Claire Weinandd72e872022-08-15 14:20:06 -07002330 << "handleBMCLogServicesCollectionGet respHandler got error "
Claire Weinanfdd26902022-03-01 14:18:25 -08002331 << ec;
2332 // Assume that getting an error simply means there are no dump
2333 // LogServices. Return without adding any error response.
2334 return;
2335 }
2336
2337 nlohmann::json& logServiceArrayLocal =
2338 asyncResp->res.jsonValue["Members"];
2339
2340 for (const std::string& path : subTreePaths)
2341 {
2342 if (path == "/xyz/openbmc_project/dump/bmc")
2343 {
Ed Tanous613dabe2022-07-09 11:17:36 -07002344 nlohmann::json::object_t member;
2345 member["@odata.id"] =
2346 "/redfish/v1/Managers/bmc/LogServices/Dump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002347 logServiceArrayLocal.emplace_back(std::move(member));
Claire Weinanfdd26902022-03-01 14:18:25 -08002348 }
2349 else if (path == "/xyz/openbmc_project/dump/faultlog")
2350 {
Ed Tanous613dabe2022-07-09 11:17:36 -07002351 nlohmann::json::object_t member;
2352 member["@odata.id"] =
2353 "/redfish/v1/Managers/bmc/LogServices/FaultLog";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002354 logServiceArrayLocal.emplace_back(std::move(member));
Claire Weinanfdd26902022-03-01 14:18:25 -08002355 }
2356 }
2357
2358 asyncResp->res.jsonValue["Members@odata.count"] =
2359 logServiceArrayLocal.size();
George Liu7a1dbc42022-12-07 16:03:22 +08002360 });
Claire Weinanfdd26902022-03-01 14:18:25 -08002361#endif
2362}
2363
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002364inline void requestRoutesBMCLogServiceCollection(App& app)
2365{
2366 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/")
Gunnar Millsad89dcf2021-07-30 14:40:11 -05002367 .privileges(redfish::privileges::getLogServiceCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002368 .methods(boost::beast::http::verb::get)(
Claire Weinandd72e872022-08-15 14:20:06 -07002369 std::bind_front(handleBMCLogServicesCollectionGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002370}
Ed Tanous1da66f72018-07-27 16:13:37 -07002371
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002372inline void requestRoutesBMCJournalLogService(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07002373{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002374 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/")
Ed Tanoused398212021-06-09 17:05:54 -07002375 .privileges(redfish::privileges::getLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002376 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002377 [&app](const crow::Request& req,
2378 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002379 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002380 {
2381 return;
2382 }
2383 asyncResp->res.jsonValue["@odata.type"] =
2384 "#LogService.v1_1_0.LogService";
2385 asyncResp->res.jsonValue["@odata.id"] =
2386 "/redfish/v1/Managers/bmc/LogServices/Journal";
2387 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Log Service";
2388 asyncResp->res.jsonValue["Description"] = "BMC Journal Log Service";
Ed Tanoused34a4a2023-02-08 15:43:27 -08002389 asyncResp->res.jsonValue["Id"] = "Journal";
Ed Tanous002d39b2022-05-31 08:59:27 -07002390 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05302391
Ed Tanous002d39b2022-05-31 08:59:27 -07002392 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07002393 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07002394 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2395 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2396 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302397
Ed Tanous002d39b2022-05-31 08:59:27 -07002398 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2399 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2400 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002401}
Jason M. Billse1f26342018-07-18 12:12:00 -07002402
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002403static int
2404 fillBMCJournalLogEntryJson(const std::string& bmcJournalLogEntryID,
2405 sd_journal* journal,
2406 nlohmann::json::object_t& bmcJournalLogEntryJson)
Jason M. Billse1f26342018-07-18 12:12:00 -07002407{
2408 // Get the Log Entry contents
2409 int ret = 0;
Jason M. Billse1f26342018-07-18 12:12:00 -07002410
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002411 std::string message;
2412 std::string_view syslogID;
2413 ret = getJournalMetadata(journal, "SYSLOG_IDENTIFIER", syslogID);
2414 if (ret < 0)
2415 {
2416 BMCWEB_LOG_ERROR << "Failed to read SYSLOG_IDENTIFIER field: "
2417 << strerror(-ret);
2418 }
2419 if (!syslogID.empty())
2420 {
2421 message += std::string(syslogID) + ": ";
2422 }
2423
Ed Tanous39e77502019-03-04 17:35:53 -08002424 std::string_view msg;
Jason M. Bills16428a12018-11-02 12:42:29 -07002425 ret = getJournalMetadata(journal, "MESSAGE", msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002426 if (ret < 0)
2427 {
2428 BMCWEB_LOG_ERROR << "Failed to read MESSAGE field: " << strerror(-ret);
2429 return 1;
2430 }
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002431 message += std::string(msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002432
2433 // Get the severity from the PRIORITY field
Ed Tanous271584a2019-07-09 16:24:22 -07002434 long int severity = 8; // Default to an invalid priority
Jason M. Bills16428a12018-11-02 12:42:29 -07002435 ret = getJournalMetadata(journal, "PRIORITY", 10, severity);
Jason M. Billse1f26342018-07-18 12:12:00 -07002436 if (ret < 0)
2437 {
2438 BMCWEB_LOG_ERROR << "Failed to read PRIORITY field: " << strerror(-ret);
Jason M. Billse1f26342018-07-18 12:12:00 -07002439 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002440
2441 // Get the Created time from the timestamp
Jason M. Bills16428a12018-11-02 12:42:29 -07002442 std::string entryTimeStr;
2443 if (!getEntryTimestamp(journal, entryTimeStr))
Jason M. Billse1f26342018-07-18 12:12:00 -07002444 {
Jason M. Bills16428a12018-11-02 12:42:29 -07002445 return 1;
Jason M. Billse1f26342018-07-18 12:12:00 -07002446 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002447
2448 // Fill in the log entry with the gathered data
Vijay Lobo9c11a172021-10-07 16:53:16 -05002449 bmcJournalLogEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07002450 bmcJournalLogEntryJson["@odata.id"] = boost::urls::format(
2451 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/{}",
Willy Tueddfc432022-09-26 16:46:38 +00002452 bmcJournalLogEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07002453 bmcJournalLogEntryJson["Name"] = "BMC Journal Entry";
2454 bmcJournalLogEntryJson["Id"] = bmcJournalLogEntryID;
2455 bmcJournalLogEntryJson["Message"] = std::move(message);
2456 bmcJournalLogEntryJson["EntryType"] = "Oem";
2457 bmcJournalLogEntryJson["Severity"] = severity <= 2 ? "Critical"
2458 : severity <= 4 ? "Warning"
2459 : "OK";
2460 bmcJournalLogEntryJson["OemRecordFormat"] = "BMC Journal Entry";
2461 bmcJournalLogEntryJson["Created"] = std::move(entryTimeStr);
Jason M. Billse1f26342018-07-18 12:12:00 -07002462 return 0;
2463}
2464
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002465inline void requestRoutesBMCJournalLogEntryCollection(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002466{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002467 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002468 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07002469 .methods(boost::beast::http::verb::get)(
2470 [&app](const crow::Request& req,
2471 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
2472 query_param::QueryCapabilities capabilities = {
2473 .canDelegateTop = true,
2474 .canDelegateSkip = true,
2475 };
2476 query_param::Query delegatedQuery;
2477 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00002478 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07002479 {
2480 return;
2481 }
Ed Tanous3648c8b2022-07-25 13:39:59 -07002482
2483 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08002484 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07002485
Ed Tanous002d39b2022-05-31 08:59:27 -07002486 // Collections don't include the static data added by SubRoute
2487 // because it has a duplicate entry for members
2488 asyncResp->res.jsonValue["@odata.type"] =
2489 "#LogEntryCollection.LogEntryCollection";
2490 asyncResp->res.jsonValue["@odata.id"] =
2491 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2492 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Entries";
2493 asyncResp->res.jsonValue["Description"] =
2494 "Collection of BMC Journal Entries";
2495 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
2496 logEntryArray = nlohmann::json::array();
Jason M. Billse1f26342018-07-18 12:12:00 -07002497
Ed Tanous002d39b2022-05-31 08:59:27 -07002498 // Go through the journal and use the timestamp to create a
2499 // unique ID for each entry
2500 sd_journal* journalTmp = nullptr;
2501 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2502 if (ret < 0)
2503 {
2504 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
2505 messages::internalError(asyncResp->res);
2506 return;
2507 }
2508 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2509 journalTmp, sd_journal_close);
2510 journalTmp = nullptr;
2511 uint64_t entryCount = 0;
2512 // Reset the unique ID on the first entry
2513 bool firstEntry = true;
2514 SD_JOURNAL_FOREACH(journal.get())
2515 {
2516 entryCount++;
2517 // Handle paging using skip (number of entries to skip from
2518 // the start) and top (number of entries to display)
Ed Tanous3648c8b2022-07-25 13:39:59 -07002519 if (entryCount <= skip || entryCount > skip + top)
George Liu0fda0f12021-11-16 10:06:17 +08002520 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002521 continue;
2522 }
2523
2524 std::string idStr;
2525 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2526 {
2527 continue;
2528 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002529 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002530
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002531 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002532 if (fillBMCJournalLogEntryJson(idStr, journal.get(),
2533 bmcJournalLogEntry) != 0)
2534 {
George Liu0fda0f12021-11-16 10:06:17 +08002535 messages::internalError(asyncResp->res);
2536 return;
2537 }
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002538 logEntryArray.emplace_back(std::move(bmcJournalLogEntry));
Ed Tanous002d39b2022-05-31 08:59:27 -07002539 }
2540 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002541 if (skip + top < entryCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07002542 {
2543 asyncResp->res.jsonValue["Members@odata.nextLink"] =
2544 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07002545 std::to_string(skip + top);
Ed Tanous002d39b2022-05-31 08:59:27 -07002546 }
George Liu0fda0f12021-11-16 10:06:17 +08002547 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002548}
Jason M. Billse1f26342018-07-18 12:12:00 -07002549
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002550inline void requestRoutesBMCJournalLogEntry(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002551{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002552 BMCWEB_ROUTE(app,
2553 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002554 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002555 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002556 [&app](const crow::Request& req,
2557 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2558 const std::string& entryID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002559 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002560 {
2561 return;
2562 }
2563 // Convert the unique ID back to a timestamp to find the entry
2564 uint64_t ts = 0;
2565 uint64_t index = 0;
2566 if (!getTimestampFromID(asyncResp, entryID, ts, index))
2567 {
2568 return;
2569 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002570
Ed Tanous002d39b2022-05-31 08:59:27 -07002571 sd_journal* journalTmp = nullptr;
2572 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2573 if (ret < 0)
2574 {
2575 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
2576 messages::internalError(asyncResp->res);
2577 return;
2578 }
2579 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2580 journalTmp, sd_journal_close);
2581 journalTmp = nullptr;
2582 // Go to the timestamp in the log and move to the entry at the
2583 // index tracking the unique ID
2584 std::string idStr;
2585 bool firstEntry = true;
2586 ret = sd_journal_seek_realtime_usec(journal.get(), ts);
2587 if (ret < 0)
2588 {
2589 BMCWEB_LOG_ERROR << "failed to seek to an entry in journal"
2590 << strerror(-ret);
2591 messages::internalError(asyncResp->res);
2592 return;
2593 }
2594 for (uint64_t i = 0; i <= index; i++)
2595 {
2596 sd_journal_next(journal.get());
2597 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2598 {
2599 messages::internalError(asyncResp->res);
2600 return;
2601 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002602 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002603 }
2604 // Confirm that the entry ID matches what was requested
2605 if (idStr != entryID)
2606 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002607 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Ed Tanous002d39b2022-05-31 08:59:27 -07002608 return;
2609 }
zhanghch058d1b46d2021-04-01 11:18:24 +08002610
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002611 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002612 if (fillBMCJournalLogEntryJson(entryID, journal.get(),
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002613 bmcJournalLogEntry) != 0)
Ed Tanous002d39b2022-05-31 08:59:27 -07002614 {
2615 messages::internalError(asyncResp->res);
2616 return;
2617 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07002618 asyncResp->res.jsonValue.update(bmcJournalLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002619 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002620}
2621
Claire Weinanfdd26902022-03-01 14:18:25 -08002622inline void
2623 getDumpServiceInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2624 const std::string& dumpType)
2625{
2626 std::string dumpPath;
2627 std::string overWritePolicy;
2628 bool collectDiagnosticDataSupported = false;
2629
2630 if (dumpType == "BMC")
2631 {
2632 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump";
2633 overWritePolicy = "WrapsWhenFull";
2634 collectDiagnosticDataSupported = true;
2635 }
2636 else if (dumpType == "FaultLog")
2637 {
2638 dumpPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog";
2639 overWritePolicy = "Unknown";
2640 collectDiagnosticDataSupported = false;
2641 }
2642 else if (dumpType == "System")
2643 {
2644 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump";
2645 overWritePolicy = "WrapsWhenFull";
2646 collectDiagnosticDataSupported = true;
2647 }
2648 else
2649 {
2650 BMCWEB_LOG_ERROR << "getDumpServiceInfo() invalid dump type: "
2651 << dumpType;
2652 messages::internalError(asyncResp->res);
2653 return;
2654 }
2655
2656 asyncResp->res.jsonValue["@odata.id"] = dumpPath;
2657 asyncResp->res.jsonValue["@odata.type"] = "#LogService.v1_2_0.LogService";
2658 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2659 asyncResp->res.jsonValue["Description"] = dumpType + " Dump LogService";
2660 asyncResp->res.jsonValue["Id"] = std::filesystem::path(dumpPath).filename();
2661 asyncResp->res.jsonValue["OverWritePolicy"] = std::move(overWritePolicy);
2662
2663 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07002664 redfish::time_utils::getDateTimeOffsetNow();
Claire Weinanfdd26902022-03-01 14:18:25 -08002665 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2666 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2667 redfishDateTimeOffset.second;
2668
2669 asyncResp->res.jsonValue["Entries"]["@odata.id"] = dumpPath + "/Entries";
Claire Weinanfdd26902022-03-01 14:18:25 -08002670
2671 if (collectDiagnosticDataSupported)
2672 {
2673 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
2674 ["target"] =
2675 dumpPath + "/Actions/LogService.CollectDiagnosticData";
2676 }
Claire Weinan0d946212022-07-13 19:40:19 -07002677
2678 constexpr std::array<std::string_view, 1> interfaces = {deleteAllInterface};
2679 dbus::utility::getSubTreePaths(
2680 "/xyz/openbmc_project/dump", 0, interfaces,
2681 [asyncResp, dumpType, dumpPath](
2682 const boost::system::error_code& ec,
2683 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
2684 if (ec)
2685 {
2686 BMCWEB_LOG_ERROR << "getDumpServiceInfo respHandler got error "
2687 << ec;
2688 // Assume that getting an error simply means there are no dump
2689 // LogServices. Return without adding any error response.
2690 return;
2691 }
2692
2693 const std::string dbusDumpPath =
2694 "/xyz/openbmc_project/dump/" +
2695 boost::algorithm::to_lower_copy(dumpType);
2696
2697 for (const std::string& path : subTreePaths)
2698 {
2699 if (path == dbusDumpPath)
2700 {
2701 asyncResp->res
2702 .jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
2703 dumpPath + "/Actions/LogService.ClearLog";
2704 break;
2705 }
2706 }
2707 });
Claire Weinanfdd26902022-03-01 14:18:25 -08002708}
2709
2710inline void handleLogServicesDumpServiceGet(
2711 crow::App& app, const std::string& dumpType, const crow::Request& req,
2712 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2713{
2714 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2715 {
2716 return;
2717 }
2718 getDumpServiceInfo(asyncResp, dumpType);
2719}
2720
Ed Tanous22d268c2022-05-19 09:39:07 -07002721inline void handleLogServicesDumpServiceComputerSystemGet(
2722 crow::App& app, const crow::Request& req,
2723 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2724 const std::string& chassisId)
2725{
2726 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2727 {
2728 return;
2729 }
2730 if (chassisId != "system")
2731 {
2732 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2733 return;
2734 }
2735 getDumpServiceInfo(asyncResp, "System");
2736}
2737
Claire Weinanfdd26902022-03-01 14:18:25 -08002738inline void handleLogServicesDumpEntriesCollectionGet(
2739 crow::App& app, const std::string& dumpType, const crow::Request& req,
2740 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2741{
2742 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2743 {
2744 return;
2745 }
2746 getDumpEntryCollection(asyncResp, dumpType);
2747}
2748
Ed Tanous22d268c2022-05-19 09:39:07 -07002749inline void handleLogServicesDumpEntriesCollectionComputerSystemGet(
2750 crow::App& app, const crow::Request& req,
2751 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2752 const std::string& chassisId)
2753{
2754 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2755 {
2756 return;
2757 }
2758 if (chassisId != "system")
2759 {
2760 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2761 return;
2762 }
2763 getDumpEntryCollection(asyncResp, "System");
2764}
2765
Claire Weinanfdd26902022-03-01 14:18:25 -08002766inline void handleLogServicesDumpEntryGet(
2767 crow::App& app, const std::string& dumpType, const crow::Request& req,
2768 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2769 const std::string& dumpId)
2770{
2771 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2772 {
2773 return;
2774 }
2775 getDumpEntryById(asyncResp, dumpId, dumpType);
2776}
Ed Tanous22d268c2022-05-19 09:39:07 -07002777inline void handleLogServicesDumpEntryComputerSystemGet(
2778 crow::App& app, const crow::Request& req,
2779 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2780 const std::string& chassisId, const std::string& dumpId)
2781{
2782 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2783 {
2784 return;
2785 }
2786 if (chassisId != "system")
2787 {
2788 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2789 return;
2790 }
2791 getDumpEntryById(asyncResp, dumpId, "System");
2792}
Claire Weinanfdd26902022-03-01 14:18:25 -08002793
2794inline void handleLogServicesDumpEntryDelete(
2795 crow::App& app, const std::string& dumpType, const crow::Request& req,
2796 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2797 const std::string& dumpId)
2798{
2799 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2800 {
2801 return;
2802 }
2803 deleteDumpEntry(asyncResp, dumpId, dumpType);
2804}
2805
Ed Tanous22d268c2022-05-19 09:39:07 -07002806inline void handleLogServicesDumpEntryComputerSystemDelete(
2807 crow::App& app, const crow::Request& req,
2808 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2809 const std::string& chassisId, const std::string& dumpId)
2810{
2811 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2812 {
2813 return;
2814 }
2815 if (chassisId != "system")
2816 {
2817 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2818 return;
2819 }
2820 deleteDumpEntry(asyncResp, dumpId, "System");
2821}
2822
Claire Weinanfdd26902022-03-01 14:18:25 -08002823inline void handleLogServicesDumpCollectDiagnosticDataPost(
2824 crow::App& app, const std::string& dumpType, const crow::Request& req,
2825 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2826{
2827 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2828 {
2829 return;
2830 }
2831 createDump(asyncResp, req, dumpType);
2832}
2833
Ed Tanous22d268c2022-05-19 09:39:07 -07002834inline void handleLogServicesDumpCollectDiagnosticDataComputerSystemPost(
2835 crow::App& app, const crow::Request& req,
2836 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2837 const std::string& chassisId)
2838{
2839 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2840 {
2841 return;
2842 }
2843 if (chassisId != "system")
2844 {
2845 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2846 return;
2847 }
2848 createDump(asyncResp, req, "System");
2849}
2850
Claire Weinanfdd26902022-03-01 14:18:25 -08002851inline void handleLogServicesDumpClearLogPost(
2852 crow::App& app, const std::string& dumpType, const crow::Request& req,
2853 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2854{
2855 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2856 {
2857 return;
2858 }
2859 clearDump(asyncResp, dumpType);
2860}
2861
Ed Tanous22d268c2022-05-19 09:39:07 -07002862inline void handleLogServicesDumpClearLogComputerSystemPost(
2863 crow::App& app, const crow::Request& req,
2864 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2865 const std::string& chassisId)
2866{
2867 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2868 {
2869 return;
2870 }
2871 if (chassisId != "system")
2872 {
2873 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2874 return;
2875 }
2876 clearDump(asyncResp, "System");
2877}
2878
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002879inline void requestRoutesBMCDumpService(App& app)
2880{
2881 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07002882 .privileges(redfish::privileges::getLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002883 .methods(boost::beast::http::verb::get)(std::bind_front(
2884 handleLogServicesDumpServiceGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002885}
2886
2887inline void requestRoutesBMCDumpEntryCollection(App& app)
2888{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002889 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002890 .privileges(redfish::privileges::getLogEntryCollection)
Claire Weinanfdd26902022-03-01 14:18:25 -08002891 .methods(boost::beast::http::verb::get)(std::bind_front(
2892 handleLogServicesDumpEntriesCollectionGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002893}
2894
2895inline void requestRoutesBMCDumpEntry(App& app)
2896{
2897 BMCWEB_ROUTE(app,
2898 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002899 .privileges(redfish::privileges::getLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002900 .methods(boost::beast::http::verb::get)(std::bind_front(
2901 handleLogServicesDumpEntryGet, std::ref(app), "BMC"));
2902
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002903 BMCWEB_ROUTE(app,
2904 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002905 .privileges(redfish::privileges::deleteLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002906 .methods(boost::beast::http::verb::delete_)(std::bind_front(
2907 handleLogServicesDumpEntryDelete, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002908}
2909
2910inline void requestRoutesBMCDumpCreate(App& app)
2911{
George Liu0fda0f12021-11-16 10:06:17 +08002912 BMCWEB_ROUTE(
2913 app,
2914 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07002915 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002916 .methods(boost::beast::http::verb::post)(
Claire Weinanfdd26902022-03-01 14:18:25 -08002917 std::bind_front(handleLogServicesDumpCollectDiagnosticDataPost,
2918 std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002919}
2920
2921inline void requestRoutesBMCDumpClear(App& app)
2922{
George Liu0fda0f12021-11-16 10:06:17 +08002923 BMCWEB_ROUTE(
2924 app,
2925 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07002926 .privileges(redfish::privileges::postLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002927 .methods(boost::beast::http::verb::post)(std::bind_front(
2928 handleLogServicesDumpClearLogPost, std::ref(app), "BMC"));
2929}
2930
2931inline void requestRoutesFaultLogDumpService(App& app)
2932{
2933 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/")
2934 .privileges(redfish::privileges::getLogService)
2935 .methods(boost::beast::http::verb::get)(std::bind_front(
2936 handleLogServicesDumpServiceGet, std::ref(app), "FaultLog"));
2937}
2938
2939inline void requestRoutesFaultLogDumpEntryCollection(App& app)
2940{
2941 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/")
2942 .privileges(redfish::privileges::getLogEntryCollection)
2943 .methods(boost::beast::http::verb::get)(
2944 std::bind_front(handleLogServicesDumpEntriesCollectionGet,
2945 std::ref(app), "FaultLog"));
2946}
2947
2948inline void requestRoutesFaultLogDumpEntry(App& app)
2949{
2950 BMCWEB_ROUTE(app,
2951 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
2952 .privileges(redfish::privileges::getLogEntry)
2953 .methods(boost::beast::http::verb::get)(std::bind_front(
2954 handleLogServicesDumpEntryGet, std::ref(app), "FaultLog"));
2955
2956 BMCWEB_ROUTE(app,
2957 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
2958 .privileges(redfish::privileges::deleteLogEntry)
2959 .methods(boost::beast::http::verb::delete_)(std::bind_front(
2960 handleLogServicesDumpEntryDelete, std::ref(app), "FaultLog"));
2961}
2962
2963inline void requestRoutesFaultLogDumpClear(App& app)
2964{
2965 BMCWEB_ROUTE(
2966 app,
2967 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Actions/LogService.ClearLog/")
2968 .privileges(redfish::privileges::postLogService)
2969 .methods(boost::beast::http::verb::post)(std::bind_front(
2970 handleLogServicesDumpClearLogPost, std::ref(app), "FaultLog"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002971}
2972
2973inline void requestRoutesSystemDumpService(App& app)
2974{
Ed Tanous22d268c2022-05-19 09:39:07 -07002975 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07002976 .privileges(redfish::privileges::getLogService)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07002977 .methods(boost::beast::http::verb::get)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07002978 handleLogServicesDumpServiceComputerSystemGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002979}
2980
2981inline void requestRoutesSystemDumpEntryCollection(App& app)
2982{
Ed Tanous22d268c2022-05-19 09:39:07 -07002983 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002984 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous22d268c2022-05-19 09:39:07 -07002985 .methods(boost::beast::http::verb::get)(std::bind_front(
2986 handleLogServicesDumpEntriesCollectionComputerSystemGet,
2987 std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002988}
2989
2990inline void requestRoutesSystemDumpEntry(App& app)
2991{
2992 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07002993 "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002994 .privileges(redfish::privileges::getLogEntry)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07002995 .methods(boost::beast::http::verb::get)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07002996 handleLogServicesDumpEntryComputerSystemGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002997
2998 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07002999 "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003000 .privileges(redfish::privileges::deleteLogEntry)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003001 .methods(boost::beast::http::verb::delete_)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003002 handleLogServicesDumpEntryComputerSystemDelete, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003003}
3004
3005inline void requestRoutesSystemDumpCreate(App& app)
3006{
George Liu0fda0f12021-11-16 10:06:17 +08003007 BMCWEB_ROUTE(
3008 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003009 "/redfish/v1/Systems/<str>/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07003010 .privileges(redfish::privileges::postLogService)
Ed Tanous22d268c2022-05-19 09:39:07 -07003011 .methods(boost::beast::http::verb::post)(std::bind_front(
3012 handleLogServicesDumpCollectDiagnosticDataComputerSystemPost,
3013 std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003014}
3015
3016inline void requestRoutesSystemDumpClear(App& app)
3017{
George Liu0fda0f12021-11-16 10:06:17 +08003018 BMCWEB_ROUTE(
3019 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003020 "/redfish/v1/Systems/<str>/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003021 .privileges(redfish::privileges::postLogService)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003022 .methods(boost::beast::http::verb::post)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003023 handleLogServicesDumpClearLogComputerSystemPost, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003024}
3025
3026inline void requestRoutesCrashdumpService(App& app)
3027{
3028 // Note: Deviated from redfish privilege registry for GET & HEAD
3029 // method for security reasons.
3030 /**
3031 * Functions triggers appropriate requests on DBus
3032 */
Ed Tanous22d268c2022-05-19 09:39:07 -07003033 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Crashdump/")
Ed Tanoused398212021-06-09 17:05:54 -07003034 // This is incorrect, should be:
3035 //.privileges(redfish::privileges::getLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003036 .privileges({{"ConfigureManager"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003037 .methods(boost::beast::http::verb::get)(
3038 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003039 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3040 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003041 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003042 {
3043 return;
3044 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003045 if (systemName != "system")
3046 {
3047 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3048 systemName);
3049 return;
3050 }
3051
Ed Tanous002d39b2022-05-31 08:59:27 -07003052 // Copy over the static data to include the entries added by
3053 // SubRoute
3054 asyncResp->res.jsonValue["@odata.id"] =
3055 "/redfish/v1/Systems/system/LogServices/Crashdump";
3056 asyncResp->res.jsonValue["@odata.type"] =
3057 "#LogService.v1_2_0.LogService";
3058 asyncResp->res.jsonValue["Name"] = "Open BMC Oem Crashdump Service";
3059 asyncResp->res.jsonValue["Description"] = "Oem Crashdump Service";
V-Sanjana15b89722023-05-11 16:27:03 +05303060 asyncResp->res.jsonValue["Id"] = "Crashdump";
Ed Tanous002d39b2022-05-31 08:59:27 -07003061 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
3062 asyncResp->res.jsonValue["MaxNumberOfRecords"] = 3;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303063
Ed Tanous002d39b2022-05-31 08:59:27 -07003064 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07003065 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07003066 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
3067 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
3068 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303069
Ed Tanous002d39b2022-05-31 08:59:27 -07003070 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
Ed Tanousef4c65b2023-04-24 15:28:50 -07003071 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
Ed Tanous002d39b2022-05-31 08:59:27 -07003072 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
3073 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.ClearLog";
3074 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
3075 ["target"] =
3076 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData";
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003077 });
3078}
3079
3080void inline requestRoutesCrashdumpClear(App& app)
3081{
George Liu0fda0f12021-11-16 10:06:17 +08003082 BMCWEB_ROUTE(
3083 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003084 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003085 // This is incorrect, should be:
3086 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003087 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003088 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003089 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003090 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3091 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003092 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003093 {
3094 return;
3095 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003096 if (systemName != "system")
3097 {
3098 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3099 systemName);
3100 return;
3101 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003102 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003103 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003104 const std::string&) {
3105 if (ec)
3106 {
3107 messages::internalError(asyncResp->res);
3108 return;
3109 }
3110 messages::success(asyncResp->res);
3111 },
3112 crashdumpObject, crashdumpPath, deleteAllInterface, "DeleteAll");
3113 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003114}
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07003115
zhanghch058d1b46d2021-04-01 11:18:24 +08003116static void
3117 logCrashdumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3118 const std::string& logID, nlohmann::json& logEntryJson)
Jason M. Billse855dd22019-10-08 11:37:48 -07003119{
Johnathan Mantey043a0532020-03-10 17:15:28 -07003120 auto getStoredLogCallback =
Ed Tanousb9d36b42022-02-26 21:42:46 -08003121 [asyncResp, logID,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003122 &logEntryJson](const boost::system::error_code& ec,
Ed Tanousb9d36b42022-02-26 21:42:46 -08003123 const dbus::utility::DBusPropertiesMap& params) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003124 if (ec)
3125 {
3126 BMCWEB_LOG_DEBUG << "failed to get log ec: " << ec.message();
3127 if (ec.value() ==
3128 boost::system::linux_error::bad_request_descriptor)
Jason M. Bills1ddcf012019-11-26 14:59:21 -08003129 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003130 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003131 }
3132 else
3133 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003134 messages::internalError(asyncResp->res);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003135 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003136 return;
3137 }
3138
3139 std::string timestamp{};
3140 std::string filename{};
3141 std::string logfile{};
3142 parseCrashdumpParameters(params, filename, timestamp, logfile);
3143
3144 if (filename.empty() || timestamp.empty())
3145 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003146 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003147 return;
3148 }
3149
3150 std::string crashdumpURI =
3151 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/" +
3152 logID + "/" + filename;
Jason M. Bills84afc482022-06-24 12:38:23 -07003153 nlohmann::json::object_t logEntry;
Vijay Lobo9c11a172021-10-07 16:53:16 -05003154 logEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07003155 logEntry["@odata.id"] = boost::urls::format(
3156 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/{}",
3157 logID);
Jason M. Bills84afc482022-06-24 12:38:23 -07003158 logEntry["Name"] = "CPU Crashdump";
3159 logEntry["Id"] = logID;
3160 logEntry["EntryType"] = "Oem";
3161 logEntry["AdditionalDataURI"] = std::move(crashdumpURI);
3162 logEntry["DiagnosticDataType"] = "OEM";
3163 logEntry["OEMDiagnosticDataType"] = "PECICrashdump";
3164 logEntry["Created"] = std::move(timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07003165
3166 // If logEntryJson references an array of LogEntry resources
3167 // ('Members' list), then push this as a new entry, otherwise set it
3168 // directly
3169 if (logEntryJson.is_array())
3170 {
3171 logEntryJson.push_back(logEntry);
3172 asyncResp->res.jsonValue["Members@odata.count"] =
3173 logEntryJson.size();
3174 }
3175 else
3176 {
Jason M. Billsd405bb52022-06-24 10:52:05 -07003177 logEntryJson.update(logEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07003178 }
3179 };
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02003180 sdbusplus::asio::getAllProperties(
3181 *crow::connections::systemBus, crashdumpObject,
3182 crashdumpPath + std::string("/") + logID, crashdumpInterface,
3183 std::move(getStoredLogCallback));
Jason M. Billse855dd22019-10-08 11:37:48 -07003184}
3185
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003186inline void requestRoutesCrashdumpEntryCollection(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07003187{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003188 // Note: Deviated from redfish privilege registry for GET & HEAD
3189 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07003190 /**
3191 * Functions triggers appropriate requests on DBus
3192 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003193 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003194 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07003195 // This is incorrect, should be.
3196 //.privileges(redfish::privileges::postLogEntryCollection)
Ed Tanous432a8902021-06-14 15:28:56 -07003197 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003198 .methods(boost::beast::http::verb::get)(
3199 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003200 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3201 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003202 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003203 {
3204 return;
3205 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003206 if (systemName != "system")
3207 {
3208 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3209 systemName);
3210 return;
3211 }
3212
George Liu7a1dbc42022-12-07 16:03:22 +08003213 constexpr std::array<std::string_view, 1> interfaces = {
3214 crashdumpInterface};
3215 dbus::utility::getSubTreePaths(
3216 "/", 0, interfaces,
3217 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003218 const std::vector<std::string>& resp) {
3219 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07003220 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003221 if (ec.value() !=
3222 boost::system::errc::no_such_file_or_directory)
3223 {
3224 BMCWEB_LOG_DEBUG << "failed to get entries ec: "
3225 << ec.message();
3226 messages::internalError(asyncResp->res);
3227 return;
3228 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07003229 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003230 asyncResp->res.jsonValue["@odata.type"] =
3231 "#LogEntryCollection.LogEntryCollection";
3232 asyncResp->res.jsonValue["@odata.id"] =
3233 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
3234 asyncResp->res.jsonValue["Name"] = "Open BMC Crashdump Entries";
3235 asyncResp->res.jsonValue["Description"] =
3236 "Collection of Crashdump Entries";
3237 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3238 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003239
Ed Tanous002d39b2022-05-31 08:59:27 -07003240 for (const std::string& path : resp)
3241 {
3242 const sdbusplus::message::object_path objPath(path);
3243 // Get the log ID
3244 std::string logID = objPath.filename();
3245 if (logID.empty())
3246 {
3247 continue;
3248 }
3249 // Add the log entry to the array
3250 logCrashdumpEntry(asyncResp, logID,
3251 asyncResp->res.jsonValue["Members"]);
3252 }
George Liu7a1dbc42022-12-07 16:03:22 +08003253 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003254 });
3255}
Ed Tanous1da66f72018-07-27 16:13:37 -07003256
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003257inline void requestRoutesCrashdumpEntry(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07003258{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003259 // Note: Deviated from redfish privilege registry for GET & HEAD
3260 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07003261
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003262 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07003263 app, "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003264 // this is incorrect, should be
3265 // .privileges(redfish::privileges::getLogEntry)
Ed Tanous432a8902021-06-14 15:28:56 -07003266 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003267 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003268 [&app](const crow::Request& req,
3269 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07003270 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003271 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003272 {
3273 return;
3274 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003275 if (systemName != "system")
3276 {
3277 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3278 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003279 return;
3280 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003281 const std::string& logID = param;
3282 logCrashdumpEntry(asyncResp, logID, asyncResp->res.jsonValue);
3283 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003284}
Ed Tanous1da66f72018-07-27 16:13:37 -07003285
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003286inline void requestRoutesCrashdumpFile(App& app)
3287{
3288 // Note: Deviated from redfish privilege registry for GET & HEAD
3289 // method for security reasons.
3290 BMCWEB_ROUTE(
3291 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003292 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/<str>/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003293 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003294 .methods(boost::beast::http::verb::get)(
Nan Zhoua4ce1142022-08-02 18:45:25 +00003295 [](const crow::Request& req,
3296 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07003297 const std::string& systemName, const std::string& logID,
3298 const std::string& fileName) {
Shounak Mitra2a9beee2022-07-20 18:41:30 +00003299 // Do not call getRedfishRoute here since the crashdump file is not a
3300 // Redfish resource.
Ed Tanous22d268c2022-05-19 09:39:07 -07003301
3302 if (systemName != "system")
3303 {
3304 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3305 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003306 return;
3307 }
3308
Ed Tanous002d39b2022-05-31 08:59:27 -07003309 auto getStoredLogCallback =
Ed Tanous39662a32023-02-06 15:09:46 -08003310 [asyncResp, logID, fileName, url(boost::urls::url(req.url()))](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003311 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003312 const std::vector<
3313 std::pair<std::string, dbus::utility::DbusVariantType>>&
3314 resp) {
3315 if (ec)
3316 {
3317 BMCWEB_LOG_DEBUG << "failed to get log ec: " << ec.message();
3318 messages::internalError(asyncResp->res);
3319 return;
3320 }
Jason M. Bills8e6c0992021-03-11 16:26:53 -08003321
Ed Tanous002d39b2022-05-31 08:59:27 -07003322 std::string dbusFilename{};
3323 std::string dbusTimestamp{};
3324 std::string dbusFilepath{};
Jason M. Bills8e6c0992021-03-11 16:26:53 -08003325
Ed Tanous002d39b2022-05-31 08:59:27 -07003326 parseCrashdumpParameters(resp, dbusFilename, dbusTimestamp,
3327 dbusFilepath);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003328
Ed Tanous002d39b2022-05-31 08:59:27 -07003329 if (dbusFilename.empty() || dbusTimestamp.empty() ||
3330 dbusFilepath.empty())
3331 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003332 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003333 return;
3334 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003335
Ed Tanous002d39b2022-05-31 08:59:27 -07003336 // Verify the file name parameter is correct
3337 if (fileName != dbusFilename)
3338 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003339 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003340 return;
3341 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003342
Ed Tanous002d39b2022-05-31 08:59:27 -07003343 if (!std::filesystem::exists(dbusFilepath))
3344 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003345 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003346 return;
3347 }
3348 std::ifstream ifs(dbusFilepath, std::ios::in | std::ios::binary);
3349 asyncResp->res.body() =
3350 std::string(std::istreambuf_iterator<char>{ifs}, {});
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003351
Ed Tanous002d39b2022-05-31 08:59:27 -07003352 // Configure this to be a file download when accessed
3353 // from a browser
Ed Tanousd9f6c622022-03-17 09:12:17 -07003354 asyncResp->res.addHeader(
3355 boost::beast::http::field::content_disposition, "attachment");
Ed Tanous002d39b2022-05-31 08:59:27 -07003356 };
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02003357 sdbusplus::asio::getAllProperties(
3358 *crow::connections::systemBus, crashdumpObject,
3359 crashdumpPath + std::string("/") + logID, crashdumpInterface,
3360 std::move(getStoredLogCallback));
Ed Tanous002d39b2022-05-31 08:59:27 -07003361 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003362}
3363
Jason M. Billsc5a4c822022-01-06 15:51:23 -08003364enum class OEMDiagnosticType
3365{
3366 onDemand,
3367 telemetry,
3368 invalid,
3369};
3370
Ed Tanous26ccae32023-02-16 10:28:44 -08003371inline OEMDiagnosticType getOEMDiagnosticType(std::string_view oemDiagStr)
Jason M. Billsc5a4c822022-01-06 15:51:23 -08003372{
3373 if (oemDiagStr == "OnDemand")
3374 {
3375 return OEMDiagnosticType::onDemand;
3376 }
3377 if (oemDiagStr == "Telemetry")
3378 {
3379 return OEMDiagnosticType::telemetry;
3380 }
3381
3382 return OEMDiagnosticType::invalid;
3383}
3384
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003385inline void requestRoutesCrashdumpCollect(App& app)
3386{
3387 // Note: Deviated from redfish privilege registry for GET & HEAD
3388 // method for security reasons.
George Liu0fda0f12021-11-16 10:06:17 +08003389 BMCWEB_ROUTE(
3390 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003391 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07003392 // The below is incorrect; Should be ConfigureManager
3393 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003394 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003395 .methods(boost::beast::http::verb::post)(
3396 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003397 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3398 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003399 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003400 {
3401 return;
3402 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003403
3404 if (systemName != "system")
3405 {
3406 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3407 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003408 return;
3409 }
3410
Ed Tanous002d39b2022-05-31 08:59:27 -07003411 std::string diagnosticDataType;
3412 std::string oemDiagnosticDataType;
3413 if (!redfish::json_util::readJsonAction(
3414 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
3415 "OEMDiagnosticDataType", oemDiagnosticDataType))
3416 {
3417 return;
3418 }
3419
3420 if (diagnosticDataType != "OEM")
3421 {
3422 BMCWEB_LOG_ERROR
3423 << "Only OEM DiagnosticDataType supported for Crashdump";
3424 messages::actionParameterValueFormatError(
3425 asyncResp->res, diagnosticDataType, "DiagnosticDataType",
3426 "CollectDiagnosticData");
3427 return;
3428 }
3429
3430 OEMDiagnosticType oemDiagType =
3431 getOEMDiagnosticType(oemDiagnosticDataType);
3432
3433 std::string iface;
3434 std::string method;
3435 std::string taskMatchStr;
3436 if (oemDiagType == OEMDiagnosticType::onDemand)
3437 {
3438 iface = crashdumpOnDemandInterface;
3439 method = "GenerateOnDemandLog";
3440 taskMatchStr = "type='signal',"
3441 "interface='org.freedesktop.DBus.Properties',"
3442 "member='PropertiesChanged',"
3443 "arg0namespace='com.intel.crashdump'";
3444 }
3445 else if (oemDiagType == OEMDiagnosticType::telemetry)
3446 {
3447 iface = crashdumpTelemetryInterface;
3448 method = "GenerateTelemetryLog";
3449 taskMatchStr = "type='signal',"
3450 "interface='org.freedesktop.DBus.Properties',"
3451 "member='PropertiesChanged',"
3452 "arg0namespace='com.intel.crashdump'";
3453 }
3454 else
3455 {
3456 BMCWEB_LOG_ERROR << "Unsupported OEMDiagnosticDataType: "
3457 << oemDiagnosticDataType;
3458 messages::actionParameterValueFormatError(
3459 asyncResp->res, oemDiagnosticDataType, "OEMDiagnosticDataType",
3460 "CollectDiagnosticData");
3461 return;
3462 }
3463
3464 auto collectCrashdumpCallback =
3465 [asyncResp, payload(task::Payload(req)),
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003466 taskMatchStr](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003467 const std::string&) mutable {
3468 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07003469 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003470 if (ec.value() == boost::system::errc::operation_not_supported)
3471 {
3472 messages::resourceInStandby(asyncResp->res);
3473 }
3474 else if (ec.value() ==
3475 boost::system::errc::device_or_resource_busy)
3476 {
3477 messages::serviceTemporarilyUnavailable(asyncResp->res,
3478 "60");
3479 }
3480 else
3481 {
3482 messages::internalError(asyncResp->res);
3483 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07003484 return;
3485 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003486 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003487 [](const boost::system::error_code& err, sdbusplus::message_t&,
Ed Tanous002d39b2022-05-31 08:59:27 -07003488 const std::shared_ptr<task::TaskData>& taskData) {
3489 if (!err)
3490 {
3491 taskData->messages.emplace_back(messages::taskCompletedOK(
3492 std::to_string(taskData->index)));
3493 taskData->state = "Completed";
3494 }
3495 return task::completed;
3496 },
3497 taskMatchStr);
Ed Tanous1da66f72018-07-27 16:13:37 -07003498
Ed Tanous002d39b2022-05-31 08:59:27 -07003499 task->startTimer(std::chrono::minutes(5));
3500 task->populateResp(asyncResp->res);
3501 task->payload.emplace(std::move(payload));
3502 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003503
Ed Tanous002d39b2022-05-31 08:59:27 -07003504 crow::connections::systemBus->async_method_call(
3505 std::move(collectCrashdumpCallback), crashdumpObject, crashdumpPath,
3506 iface, method);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003507 });
3508}
Kenny L. Ku6eda7682020-06-19 09:48:36 -07003509
Andrew Geisslercb92c032018-08-17 07:56:14 -07003510/**
3511 * DBusLogServiceActionsClear class supports POST method for ClearLog action.
3512 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003513inline void requestRoutesDBusLogServiceActionsClear(App& app)
Andrew Geisslercb92c032018-08-17 07:56:14 -07003514{
Andrew Geisslercb92c032018-08-17 07:56:14 -07003515 /**
3516 * Function handles POST method request.
3517 * The Clear Log actions does not require any parameter.The action deletes
3518 * all entries found in the Entries collection for this Log Service.
3519 */
Andrew Geisslercb92c032018-08-17 07:56:14 -07003520
George Liu0fda0f12021-11-16 10:06:17 +08003521 BMCWEB_ROUTE(
3522 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003523 "/redfish/v1/Systems/<str>/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003524 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003525 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003526 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003527 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3528 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003529 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003530 {
3531 return;
3532 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003533 if (systemName != "system")
3534 {
3535 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3536 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003537 return;
3538 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003539 BMCWEB_LOG_DEBUG << "Do delete all entries.";
Andrew Geisslercb92c032018-08-17 07:56:14 -07003540
Ed Tanous002d39b2022-05-31 08:59:27 -07003541 // Process response from Logging service.
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003542 auto respHandler = [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003543 BMCWEB_LOG_DEBUG << "doClearLog resp_handler callback: Done";
3544 if (ec)
3545 {
3546 // TODO Handle for specific error code
3547 BMCWEB_LOG_ERROR << "doClearLog resp_handler got error " << ec;
3548 asyncResp->res.result(
3549 boost::beast::http::status::internal_server_error);
3550 return;
3551 }
Andrew Geisslercb92c032018-08-17 07:56:14 -07003552
Ed Tanous002d39b2022-05-31 08:59:27 -07003553 asyncResp->res.result(boost::beast::http::status::no_content);
3554 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003555
Ed Tanous002d39b2022-05-31 08:59:27 -07003556 // Make call to Logging service to request Clear Log
3557 crow::connections::systemBus->async_method_call(
3558 respHandler, "xyz.openbmc_project.Logging",
3559 "/xyz/openbmc_project/logging",
3560 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3561 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003562}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003563
3564/****************************************************
3565 * Redfish PostCode interfaces
3566 * using DBUS interface: getPostCodesTS
3567 ******************************************************/
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003568inline void requestRoutesPostCodesLogService(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003569{
Ed Tanous22d268c2022-05-19 09:39:07 -07003570 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/PostCodes/")
Ed Tanoused398212021-06-09 17:05:54 -07003571 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07003572 .methods(boost::beast::http::verb::get)(
3573 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003574 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3575 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003576 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003577 {
3578 return;
3579 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003580 if (systemName != "system")
3581 {
3582 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3583 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003584 return;
3585 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003586 asyncResp->res.jsonValue["@odata.id"] =
3587 "/redfish/v1/Systems/system/LogServices/PostCodes";
3588 asyncResp->res.jsonValue["@odata.type"] =
3589 "#LogService.v1_1_0.LogService";
3590 asyncResp->res.jsonValue["Name"] = "POST Code Log Service";
3591 asyncResp->res.jsonValue["Description"] = "POST Code Log Service";
Ed Tanoused34a4a2023-02-08 15:43:27 -08003592 asyncResp->res.jsonValue["Id"] = "PostCodes";
Ed Tanous002d39b2022-05-31 08:59:27 -07003593 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
3594 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
3595 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
Tejas Patil7c8c4052021-06-04 17:43:14 +05303596
Ed Tanous002d39b2022-05-31 08:59:27 -07003597 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07003598 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07003599 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
3600 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
3601 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303602
Ed Tanous002d39b2022-05-31 08:59:27 -07003603 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
3604 {"target",
3605 "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/LogService.ClearLog"}};
George Liu0fda0f12021-11-16 10:06:17 +08003606 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003607}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003608
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003609inline void requestRoutesPostCodesClear(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003610{
George Liu0fda0f12021-11-16 10:06:17 +08003611 BMCWEB_ROUTE(
3612 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003613 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003614 // The following privilege is incorrect; It should be ConfigureManager
3615 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003616 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003617 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003618 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003619 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3620 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003621 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003622 {
3623 return;
3624 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003625 if (systemName != "system")
3626 {
3627 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3628 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003629 return;
3630 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003631 BMCWEB_LOG_DEBUG << "Do delete all postcodes entries.";
ZhikuiRena3316fc2020-01-29 14:58:08 -08003632
Ed Tanous002d39b2022-05-31 08:59:27 -07003633 // Make call to post-code service to request clear all
3634 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003635 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003636 if (ec)
3637 {
3638 // TODO Handle for specific error code
3639 BMCWEB_LOG_ERROR << "doClearPostCodes resp_handler got error "
3640 << ec;
3641 asyncResp->res.result(
3642 boost::beast::http::status::internal_server_error);
3643 messages::internalError(asyncResp->res);
3644 return;
3645 }
3646 },
3647 "xyz.openbmc_project.State.Boot.PostCode0",
3648 "/xyz/openbmc_project/State/Boot/PostCode0",
3649 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3650 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003651}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003652
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003653/**
3654 * @brief Parse post code ID and get the current value and index value
3655 * eg: postCodeID=B1-2, currentValue=1, index=2
3656 *
3657 * @param[in] postCodeID Post Code ID
3658 * @param[out] currentValue Current value
3659 * @param[out] index Index value
3660 *
3661 * @return bool true if the parsing is successful, false the parsing fails
3662 */
3663inline static bool parsePostCode(const std::string& postCodeID,
3664 uint64_t& currentValue, uint16_t& index)
3665{
3666 std::vector<std::string> split;
Ed Tanous50ebd4a2023-01-19 19:03:17 -08003667 bmcweb::split(split, postCodeID, '-');
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003668 if (split.size() != 2 || split[0].length() < 2 || split[0].front() != 'B')
3669 {
3670 return false;
3671 }
3672
Patrick Williams84396af2023-05-11 11:47:45 -05003673 auto start = std::next(split[0].begin());
3674 auto end = split[0].end();
3675 auto [ptrIndex, ecIndex] = std::from_chars(&*start, &*end, index);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003676
Patrick Williams84396af2023-05-11 11:47:45 -05003677 if (ptrIndex != &*end || ecIndex != std::errc())
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003678 {
3679 return false;
3680 }
3681
Patrick Williams84396af2023-05-11 11:47:45 -05003682 start = split[1].begin();
3683 end = split[1].end();
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003684
Patrick Williams84396af2023-05-11 11:47:45 -05003685 auto [ptrValue, ecValue] = std::from_chars(&*start, &*end, currentValue);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003686
Patrick Williams84396af2023-05-11 11:47:45 -05003687 return ptrValue == &*end && ecValue == std::errc();
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003688}
3689
3690static bool fillPostCodeEntry(
Ed Tanousac106bf2023-06-07 09:24:59 -07003691 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303692 const boost::container::flat_map<
3693 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>& postcode,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003694 const uint16_t bootIndex, const uint64_t codeIndex = 0,
3695 const uint64_t skip = 0, const uint64_t top = 0)
3696{
3697 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08003698 const registries::Message* message =
3699 registries::getMessage("OpenBMC.0.2.BIOSPOSTCode");
ZhikuiRena3316fc2020-01-29 14:58:08 -08003700
3701 uint64_t currentCodeIndex = 0;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003702 uint64_t firstCodeTimeUs = 0;
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303703 for (const std::pair<uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3704 code : postcode)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003705 {
3706 currentCodeIndex++;
3707 std::string postcodeEntryID =
3708 "B" + std::to_string(bootIndex) + "-" +
3709 std::to_string(currentCodeIndex); // 1 based index in EntryID string
3710
3711 uint64_t usecSinceEpoch = code.first;
3712 uint64_t usTimeOffset = 0;
3713
3714 if (1 == currentCodeIndex)
3715 { // already incremented
3716 firstCodeTimeUs = code.first;
3717 }
3718 else
3719 {
3720 usTimeOffset = code.first - firstCodeTimeUs;
3721 }
3722
3723 // skip if no specific codeIndex is specified and currentCodeIndex does
3724 // not fall between top and skip
3725 if ((codeIndex == 0) &&
3726 (currentCodeIndex <= skip || currentCodeIndex > top))
3727 {
3728 continue;
3729 }
3730
Gunnar Mills4e0453b2020-07-08 14:00:30 -05003731 // skip if a specific codeIndex is specified and does not match the
ZhikuiRena3316fc2020-01-29 14:58:08 -08003732 // currentIndex
3733 if ((codeIndex > 0) && (currentCodeIndex != codeIndex))
3734 {
3735 // This is done for simplicity. 1st entry is needed to calculate
3736 // time offset. To improve efficiency, one can get to the entry
3737 // directly (possibly with flatmap's nth method)
3738 continue;
3739 }
3740
3741 // currentCodeIndex is within top and skip or equal to specified code
3742 // index
3743
3744 // Get the Created time from the timestamp
3745 std::string entryTimeStr;
Konstantin Aladyshev2a025612023-02-15 11:52:58 +03003746 entryTimeStr = redfish::time_utils::getDateTimeUintUs(usecSinceEpoch);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003747
3748 // assemble messageArgs: BootIndex, TimeOffset(100us), PostCode(hex)
3749 std::ostringstream hexCode;
3750 hexCode << "0x" << std::setfill('0') << std::setw(2) << std::hex
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303751 << std::get<0>(code.second);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003752 std::ostringstream timeOffsetStr;
3753 // Set Fixed -Point Notation
3754 timeOffsetStr << std::fixed;
3755 // Set precision to 4 digits
3756 timeOffsetStr << std::setprecision(4);
3757 // Add double to stream
3758 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000;
3759 std::vector<std::string> messageArgs = {
3760 std::to_string(bootIndex), timeOffsetStr.str(), hexCode.str()};
3761
3762 // Get MessageArgs template from message registry
3763 std::string msg;
3764 if (message != nullptr)
3765 {
3766 msg = message->message;
3767
3768 // fill in this post code value
3769 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003770 for (const std::string& messageArg : messageArgs)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003771 {
3772 std::string argStr = "%" + std::to_string(++i);
3773 size_t argPos = msg.find(argStr);
3774 if (argPos != std::string::npos)
3775 {
3776 msg.replace(argPos, argStr.length(), messageArg);
3777 }
3778 }
3779 }
3780
Tim Leed4342a92020-04-27 11:47:58 +08003781 // Get Severity template from message registry
3782 std::string severity;
3783 if (message != nullptr)
3784 {
Ed Tanous5f2b84e2022-02-08 00:41:53 -08003785 severity = message->messageSeverity;
Tim Leed4342a92020-04-27 11:47:58 +08003786 }
3787
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003788 // Format entry
3789 nlohmann::json::object_t bmcLogEntry;
Vijay Lobo9c11a172021-10-07 16:53:16 -05003790 bmcLogEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07003791 bmcLogEntry["@odata.id"] = boost::urls::format(
3792 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/{}",
3793 postcodeEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07003794 bmcLogEntry["Name"] = "POST Code Log Entry";
3795 bmcLogEntry["Id"] = postcodeEntryID;
3796 bmcLogEntry["Message"] = std::move(msg);
3797 bmcLogEntry["MessageId"] = "OpenBMC.0.2.BIOSPOSTCode";
3798 bmcLogEntry["MessageArgs"] = std::move(messageArgs);
3799 bmcLogEntry["EntryType"] = "Event";
3800 bmcLogEntry["Severity"] = std::move(severity);
3801 bmcLogEntry["Created"] = entryTimeStr;
George Liu647b3cd2021-07-05 12:43:56 +08003802 if (!std::get<std::vector<uint8_t>>(code.second).empty())
3803 {
3804 bmcLogEntry["AdditionalDataURI"] =
3805 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/" +
3806 postcodeEntryID + "/attachment";
3807 }
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003808
3809 // codeIndex is only specified when querying single entry, return only
3810 // that entry in this case
3811 if (codeIndex != 0)
3812 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003813 asyncResp->res.jsonValue.update(bmcLogEntry);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003814 return true;
3815 }
3816
Ed Tanousac106bf2023-06-07 09:24:59 -07003817 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
Patrick Williamsb2ba3072023-05-12 10:27:39 -05003818 logEntryArray.emplace_back(std::move(bmcLogEntry));
ZhikuiRena3316fc2020-01-29 14:58:08 -08003819 }
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003820
3821 // Return value is always false when querying multiple entries
3822 return false;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003823}
3824
Ed Tanousac106bf2023-06-07 09:24:59 -07003825static void
3826 getPostCodeForEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3827 const std::string& entryId)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003828{
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003829 uint16_t bootIndex = 0;
3830 uint64_t codeIndex = 0;
3831 if (!parsePostCode(entryId, codeIndex, bootIndex))
3832 {
3833 // Requested ID was not found
Ed Tanousac106bf2023-06-07 09:24:59 -07003834 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003835 return;
3836 }
3837
3838 if (bootIndex == 0 || codeIndex == 0)
3839 {
3840 // 0 is an invalid index
Ed Tanousac106bf2023-06-07 09:24:59 -07003841 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003842 return;
3843 }
3844
ZhikuiRena3316fc2020-01-29 14:58:08 -08003845 crow::connections::systemBus->async_method_call(
Ed Tanousac106bf2023-06-07 09:24:59 -07003846 [asyncResp, entryId, bootIndex,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003847 codeIndex](const boost::system::error_code& ec,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303848 const boost::container::flat_map<
3849 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3850 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003851 if (ec)
3852 {
3853 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
Ed Tanousac106bf2023-06-07 09:24:59 -07003854 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07003855 return;
3856 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003857
Ed Tanous002d39b2022-05-31 08:59:27 -07003858 if (postcode.empty())
3859 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003860 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Ed Tanous002d39b2022-05-31 08:59:27 -07003861 return;
3862 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003863
Ed Tanousac106bf2023-06-07 09:24:59 -07003864 if (!fillPostCodeEntry(asyncResp, postcode, bootIndex, codeIndex))
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003865 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003866 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003867 return;
3868 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003869 },
Jonathan Doman15124762021-01-07 17:54:17 -08003870 "xyz.openbmc_project.State.Boot.PostCode0",
3871 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08003872 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3873 bootIndex);
3874}
3875
Ed Tanousac106bf2023-06-07 09:24:59 -07003876static void
3877 getPostCodeForBoot(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3878 const uint16_t bootIndex, const uint16_t bootCount,
3879 const uint64_t entryCount, size_t skip, size_t top)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003880{
3881 crow::connections::systemBus->async_method_call(
Ed Tanousac106bf2023-06-07 09:24:59 -07003882 [asyncResp, bootIndex, bootCount, entryCount, skip,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003883 top](const boost::system::error_code& ec,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303884 const boost::container::flat_map<
3885 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3886 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003887 if (ec)
3888 {
3889 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
Ed Tanousac106bf2023-06-07 09:24:59 -07003890 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07003891 return;
3892 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003893
Ed Tanous002d39b2022-05-31 08:59:27 -07003894 uint64_t endCount = entryCount;
3895 if (!postcode.empty())
3896 {
3897 endCount = entryCount + postcode.size();
Ed Tanous3648c8b2022-07-25 13:39:59 -07003898 if (skip < endCount && (top + skip) > entryCount)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003899 {
Patrick Williams89492a12023-05-10 07:51:34 -05003900 uint64_t thisBootSkip = std::max(static_cast<uint64_t>(skip),
3901 entryCount) -
3902 entryCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07003903 uint64_t thisBootTop =
Ed Tanous3648c8b2022-07-25 13:39:59 -07003904 std::min(static_cast<uint64_t>(top + skip), endCount) -
3905 entryCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07003906
Ed Tanousac106bf2023-06-07 09:24:59 -07003907 fillPostCodeEntry(asyncResp, postcode, bootIndex, 0,
3908 thisBootSkip, thisBootTop);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003909 }
Ed Tanousac106bf2023-06-07 09:24:59 -07003910 asyncResp->res.jsonValue["Members@odata.count"] = endCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07003911 }
3912
3913 // continue to previous bootIndex
3914 if (bootIndex < bootCount)
3915 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003916 getPostCodeForBoot(asyncResp, static_cast<uint16_t>(bootIndex + 1),
Ed Tanous002d39b2022-05-31 08:59:27 -07003917 bootCount, endCount, skip, top);
3918 }
Jiaqing Zhao81584ab2022-07-28 00:33:45 +08003919 else if (skip + top < endCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07003920 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003921 asyncResp->res.jsonValue["Members@odata.nextLink"] =
Ed Tanous002d39b2022-05-31 08:59:27 -07003922 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries?$skip=" +
3923 std::to_string(skip + top);
3924 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003925 },
Jonathan Doman15124762021-01-07 17:54:17 -08003926 "xyz.openbmc_project.State.Boot.PostCode0",
3927 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08003928 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3929 bootIndex);
3930}
3931
zhanghch058d1b46d2021-04-01 11:18:24 +08003932static void
Ed Tanousac106bf2023-06-07 09:24:59 -07003933 getCurrentBootNumber(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous3648c8b2022-07-25 13:39:59 -07003934 size_t skip, size_t top)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003935{
3936 uint64_t entryCount = 0;
Jonathan Doman1e1e5982021-06-11 09:36:17 -07003937 sdbusplus::asio::getProperty<uint16_t>(
3938 *crow::connections::systemBus,
3939 "xyz.openbmc_project.State.Boot.PostCode0",
3940 "/xyz/openbmc_project/State/Boot/PostCode0",
3941 "xyz.openbmc_project.State.Boot.PostCode", "CurrentBootCycleCount",
Ed Tanousac106bf2023-06-07 09:24:59 -07003942 [asyncResp, entryCount, skip, top](const boost::system::error_code& ec,
3943 const uint16_t bootCount) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003944 if (ec)
3945 {
3946 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
Ed Tanousac106bf2023-06-07 09:24:59 -07003947 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07003948 return;
3949 }
Ed Tanousac106bf2023-06-07 09:24:59 -07003950 getPostCodeForBoot(asyncResp, 1, bootCount, entryCount, skip, top);
Jonathan Doman1e1e5982021-06-11 09:36:17 -07003951 });
ZhikuiRena3316fc2020-01-29 14:58:08 -08003952}
3953
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003954inline void requestRoutesPostCodesEntryCollection(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003955{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003956 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003957 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07003958 .privileges(redfish::privileges::getLogEntryCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003959 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003960 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003961 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3962 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003963 query_param::QueryCapabilities capabilities = {
3964 .canDelegateTop = true,
3965 .canDelegateSkip = true,
3966 };
3967 query_param::Query delegatedQuery;
3968 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00003969 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07003970 {
3971 return;
3972 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003973
3974 if (systemName != "system")
3975 {
3976 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3977 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003978 return;
3979 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003980 asyncResp->res.jsonValue["@odata.type"] =
3981 "#LogEntryCollection.LogEntryCollection";
3982 asyncResp->res.jsonValue["@odata.id"] =
3983 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
3984 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
3985 asyncResp->res.jsonValue["Description"] =
3986 "Collection of POST Code Log Entries";
3987 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3988 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Ed Tanous3648c8b2022-07-25 13:39:59 -07003989 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08003990 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07003991 getCurrentBootNumber(asyncResp, skip, top);
Ed Tanous002d39b2022-05-31 08:59:27 -07003992 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003993}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003994
George Liu647b3cd2021-07-05 12:43:56 +08003995inline void requestRoutesPostCodesEntryAdditionalData(App& app)
3996{
George Liu0fda0f12021-11-16 10:06:17 +08003997 BMCWEB_ROUTE(
3998 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003999 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/<str>/attachment/")
George Liu647b3cd2021-07-05 12:43:56 +08004000 .privileges(redfish::privileges::getLogEntry)
4001 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07004002 [&app](const crow::Request& req,
4003 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07004004 const std::string& systemName,
Ed Tanous45ca1b82022-03-25 13:07:27 -07004005 const std::string& postCodeID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00004006 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07004007 {
4008 return;
4009 }
Matt Spinler72e21372023-04-19 12:53:33 -05004010 if (!http_helpers::isContentTypeAllowed(
Ed Tanous99351cd2022-08-07 16:42:51 -07004011 req.getHeaderValue("Accept"),
Ed Tanous4a0e1a02022-09-21 15:28:04 -07004012 http_helpers::ContentType::OctetStream, true))
Ed Tanous002d39b2022-05-31 08:59:27 -07004013 {
4014 asyncResp->res.result(boost::beast::http::status::bad_request);
4015 return;
4016 }
Ed Tanous22d268c2022-05-19 09:39:07 -07004017 if (systemName != "system")
4018 {
4019 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4020 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07004021 return;
4022 }
George Liu647b3cd2021-07-05 12:43:56 +08004023
Ed Tanous002d39b2022-05-31 08:59:27 -07004024 uint64_t currentValue = 0;
4025 uint16_t index = 0;
4026 if (!parsePostCode(postCodeID, currentValue, index))
4027 {
4028 messages::resourceNotFound(asyncResp->res, "LogEntry", postCodeID);
4029 return;
4030 }
George Liu647b3cd2021-07-05 12:43:56 +08004031
Ed Tanous002d39b2022-05-31 08:59:27 -07004032 crow::connections::systemBus->async_method_call(
4033 [asyncResp, postCodeID, currentValue](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08004034 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07004035 const std::vector<std::tuple<uint64_t, std::vector<uint8_t>>>&
4036 postcodes) {
4037 if (ec.value() == EBADR)
4038 {
4039 messages::resourceNotFound(asyncResp->res, "LogEntry",
4040 postCodeID);
4041 return;
4042 }
4043 if (ec)
4044 {
4045 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
4046 messages::internalError(asyncResp->res);
4047 return;
4048 }
George Liu647b3cd2021-07-05 12:43:56 +08004049
Ed Tanous002d39b2022-05-31 08:59:27 -07004050 size_t value = static_cast<size_t>(currentValue) - 1;
4051 if (value == std::string::npos || postcodes.size() < currentValue)
4052 {
Gunnar Millsa7405d52023-02-22 13:23:23 -06004053 BMCWEB_LOG_WARNING << "Wrong currentValue value";
Ed Tanous002d39b2022-05-31 08:59:27 -07004054 messages::resourceNotFound(asyncResp->res, "LogEntry",
4055 postCodeID);
4056 return;
4057 }
George Liu647b3cd2021-07-05 12:43:56 +08004058
Ed Tanous002d39b2022-05-31 08:59:27 -07004059 const auto& [tID, c] = postcodes[value];
4060 if (c.empty())
4061 {
Gunnar Millsa7405d52023-02-22 13:23:23 -06004062 BMCWEB_LOG_WARNING << "No found post code data";
Ed Tanous002d39b2022-05-31 08:59:27 -07004063 messages::resourceNotFound(asyncResp->res, "LogEntry",
4064 postCodeID);
4065 return;
4066 }
4067 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4068 const char* d = reinterpret_cast<const char*>(c.data());
4069 std::string_view strData(d, c.size());
George Liu647b3cd2021-07-05 12:43:56 +08004070
Ed Tanousd9f6c622022-03-17 09:12:17 -07004071 asyncResp->res.addHeader(boost::beast::http::field::content_type,
Ed Tanous002d39b2022-05-31 08:59:27 -07004072 "application/octet-stream");
Ed Tanousd9f6c622022-03-17 09:12:17 -07004073 asyncResp->res.addHeader(
4074 boost::beast::http::field::content_transfer_encoding, "Base64");
Ed Tanous002d39b2022-05-31 08:59:27 -07004075 asyncResp->res.body() = crow::utility::base64encode(strData);
4076 },
4077 "xyz.openbmc_project.State.Boot.PostCode0",
4078 "/xyz/openbmc_project/State/Boot/PostCode0",
4079 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodes", index);
4080 });
George Liu647b3cd2021-07-05 12:43:56 +08004081}
4082
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004083inline void requestRoutesPostCodesEntry(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004084{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004085 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07004086 app, "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07004087 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004088 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07004089 [&app](const crow::Request& req,
4090 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07004091 const std::string& systemName, const std::string& targetID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00004092 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07004093 {
4094 return;
4095 }
Ed Tanous22d268c2022-05-19 09:39:07 -07004096 if (systemName != "system")
4097 {
4098 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4099 systemName);
4100 return;
4101 }
4102
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08004103 getPostCodeForEntry(asyncResp, targetID);
Ed Tanous002d39b2022-05-31 08:59:27 -07004104 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004105}
ZhikuiRena3316fc2020-01-29 14:58:08 -08004106
Ed Tanous1da66f72018-07-27 16:13:37 -07004107} // namespace redfish