blob: 3cf6599a1041fff9ddb48eb8bc9ae7b8c17133ea [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 Tanous3544d2a2023-08-06 18:12:20 -070053#include <ranges>
Ed Tanous26702d02021-11-03 15:02:33 -070054#include <span>
Jason M. Billscd225da2019-05-08 15:31:57 -070055#include <string_view>
Ed Tanousabf2add2019-01-22 16:40:12 -080056#include <variant>
Ed Tanous1da66f72018-07-27 16:13:37 -070057
58namespace redfish
59{
60
Patrick Williams89492a12023-05-10 07:51:34 -050061constexpr const char* crashdumpObject = "com.intel.crashdump";
62constexpr const char* crashdumpPath = "/com/intel/crashdump";
63constexpr const char* crashdumpInterface = "com.intel.crashdump";
64constexpr const char* deleteAllInterface =
Jason M. Bills5b61b5e2019-10-16 10:59:02 -070065 "xyz.openbmc_project.Collection.DeleteAll";
Patrick Williams89492a12023-05-10 07:51:34 -050066constexpr const char* crashdumpOnDemandInterface =
Jason M. Bills424c4172019-03-21 13:50:33 -070067 "com.intel.crashdump.OnDemand";
Patrick Williams89492a12023-05-10 07:51:34 -050068constexpr const char* crashdumpTelemetryInterface =
Kenny L. Ku6eda7682020-06-19 09:48:36 -070069 "com.intel.crashdump.Telemetry";
Ed Tanous1da66f72018-07-27 16:13:37 -070070
Asmitha Karunanithi8e317782020-12-10 03:35:05 -060071enum class DumpCreationProgress
72{
73 DUMP_CREATE_SUCCESS,
74 DUMP_CREATE_FAILED,
75 DUMP_CREATE_INPROGRESS
76};
77
James Feistf6150402019-01-08 10:36:20 -080078namespace fs = std::filesystem;
Ed Tanous1da66f72018-07-27 16:13:37 -070079
Gunnar Mills1214b7e2020-06-04 10:11:30 -050080inline std::string translateSeverityDbusToRedfish(const std::string& s)
Andrew Geisslercb92c032018-08-17 07:56:14 -070081{
Ed Tanousd4d25792020-09-29 15:15:03 -070082 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Alert") ||
83 (s == "xyz.openbmc_project.Logging.Entry.Level.Critical") ||
84 (s == "xyz.openbmc_project.Logging.Entry.Level.Emergency") ||
85 (s == "xyz.openbmc_project.Logging.Entry.Level.Error"))
Andrew Geisslercb92c032018-08-17 07:56:14 -070086 {
87 return "Critical";
88 }
Ed Tanous3174e4d2020-10-07 11:41:22 -070089 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Debug") ||
90 (s == "xyz.openbmc_project.Logging.Entry.Level.Informational") ||
91 (s == "xyz.openbmc_project.Logging.Entry.Level.Notice"))
Andrew Geisslercb92c032018-08-17 07:56:14 -070092 {
93 return "OK";
94 }
Ed Tanous3174e4d2020-10-07 11:41:22 -070095 if (s == "xyz.openbmc_project.Logging.Entry.Level.Warning")
Andrew Geisslercb92c032018-08-17 07:56:14 -070096 {
97 return "Warning";
98 }
99 return "";
100}
101
Abhishek Patel9017faf2021-09-14 22:48:55 -0500102inline std::optional<bool> getProviderNotifyAction(const std::string& notify)
103{
104 std::optional<bool> notifyAction;
105 if (notify == "xyz.openbmc_project.Logging.Entry.Notify.Notify")
106 {
107 notifyAction = true;
108 }
109 else if (notify == "xyz.openbmc_project.Logging.Entry.Notify.Inhibit")
110 {
111 notifyAction = false;
112 }
113
114 return notifyAction;
115}
116
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700117inline static int getJournalMetadata(sd_journal* journal,
Ed Tanous26ccae32023-02-16 10:28:44 -0800118 std::string_view field,
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700119 std::string_view& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700120{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500121 const char* data = nullptr;
Jason M. Bills16428a12018-11-02 12:42:29 -0700122 size_t length = 0;
123 int ret = 0;
124 // Get the metadata from the requested field of the journal entry
Ed Tanous46ff87b2022-01-07 09:25:51 -0800125 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
126 const void** dataVoid = reinterpret_cast<const void**>(&data);
127
128 ret = sd_journal_get_data(journal, field.data(), dataVoid, &length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700129 if (ret < 0)
130 {
131 return ret;
132 }
Ed Tanous39e77502019-03-04 17:35:53 -0800133 contents = std::string_view(data, length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700134 // Only use the content after the "=" character.
Ed Tanous81ce6092020-12-17 16:54:55 +0000135 contents.remove_prefix(std::min(contents.find('=') + 1, contents.size()));
Jason M. Bills16428a12018-11-02 12:42:29 -0700136 return ret;
137}
138
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700139inline static int getJournalMetadata(sd_journal* journal,
Ed Tanous26ccae32023-02-16 10:28:44 -0800140 std::string_view field, const int& base,
141 long int& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700142{
143 int ret = 0;
Ed Tanous39e77502019-03-04 17:35:53 -0800144 std::string_view metadata;
Jason M. Bills16428a12018-11-02 12:42:29 -0700145 // Get the metadata from the requested field of the journal entry
146 ret = getJournalMetadata(journal, field, metadata);
147 if (ret < 0)
148 {
149 return ret;
150 }
Ed Tanousb01bf292019-03-25 19:25:26 +0000151 contents = strtol(metadata.data(), nullptr, base);
Jason M. Bills16428a12018-11-02 12:42:29 -0700152 return ret;
153}
154
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700155inline static bool getEntryTimestamp(sd_journal* journal,
156 std::string& entryTimestamp)
ZhikuiRena3316fc2020-01-29 14:58:08 -0800157{
158 int ret = 0;
159 uint64_t timestamp = 0;
160 ret = sd_journal_get_realtime_usec(journal, &timestamp);
161 if (ret < 0)
162 {
Ed Tanous62598e32023-07-17 17:06:25 -0700163 BMCWEB_LOG_ERROR("Failed to read entry timestamp: {}", strerror(-ret));
ZhikuiRena3316fc2020-01-29 14:58:08 -0800164 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700186 BMCWEB_LOG_ERROR("Failed to read entry timestamp: {}", strerror(-ret));
Jason M. Bills16428a12018-11-02 12:42:29 -0700187 return false;
188 }
189 // If the timestamp isn't unique, increment the index
190 if (curTs == prevTs)
191 {
192 index++;
193 }
194 else
195 {
196 // Otherwise, reset it
197 index = 0;
198 }
199 // Save the timestamp
200 prevTs = curTs;
201
202 entryID = std::to_string(curTs);
203 if (index > 0)
204 {
205 entryID += "_" + std::to_string(index);
206 }
207 return true;
208}
209
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500210static bool getUniqueEntryID(const std::string& logEntry, std::string& entryID,
Jason M. Billse85d6b12019-07-29 17:01:15 -0700211 const bool firstEntry = true)
Jason M. Bills95820182019-04-22 16:25:34 -0700212{
Ed Tanous271584a2019-07-09 16:24:22 -0700213 static time_t prevTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700214 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700215 if (firstEntry)
216 {
217 prevTs = 0;
218 }
219
Jason M. Bills95820182019-04-22 16:25:34 -0700220 // Get the entry timestamp
Ed Tanous271584a2019-07-09 16:24:22 -0700221 std::time_t curTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700222 std::tm timeStruct = {};
223 std::istringstream entryStream(logEntry);
224 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
225 {
226 curTs = std::mktime(&timeStruct);
227 }
228 // If the timestamp isn't unique, increment the index
229 if (curTs == prevTs)
230 {
231 index++;
232 }
233 else
234 {
235 // Otherwise, reset it
236 index = 0;
237 }
238 // Save the timestamp
239 prevTs = curTs;
240
241 entryID = std::to_string(curTs);
242 if (index > 0)
243 {
244 entryID += "_" + std::to_string(index);
245 }
246 return true;
247}
248
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700249inline static bool
zhanghch058d1b46d2021-04-01 11:18:24 +0800250 getTimestampFromID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
251 const std::string& entryID, uint64_t& timestamp,
252 uint64_t& index)
Jason M. Bills16428a12018-11-02 12:42:29 -0700253{
254 if (entryID.empty())
255 {
256 return false;
257 }
258 // Convert the unique ID back to a timestamp to find the entry
Ed Tanous39e77502019-03-04 17:35:53 -0800259 std::string_view tsStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700260
Ed Tanous81ce6092020-12-17 16:54:55 +0000261 auto underscorePos = tsStr.find('_');
Ed Tanous71d5d8d2022-01-25 11:04:33 -0800262 if (underscorePos != std::string_view::npos)
Jason M. Bills16428a12018-11-02 12:42:29 -0700263 {
264 // Timestamp has an index
265 tsStr.remove_suffix(tsStr.size() - underscorePos);
Ed Tanous39e77502019-03-04 17:35:53 -0800266 std::string_view indexStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700267 indexStr.remove_prefix(underscorePos + 1);
Patrick Williams84396af2023-05-11 11:47:45 -0500268 auto [ptr, ec] = std::from_chars(indexStr.begin(), indexStr.end(),
269 index);
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700270 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700271 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +0800272 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700273 return false;
274 }
275 }
276 // Timestamp has no index
Patrick Williams84396af2023-05-11 11:47:45 -0500277 auto [ptr, ec] = std::from_chars(tsStr.begin(), tsStr.end(), timestamp);
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700278 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700279 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +0800280 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700281 return false;
282 }
283 return true;
284}
285
Jason M. Bills95820182019-04-22 16:25:34 -0700286static bool
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500287 getRedfishLogFiles(std::vector<std::filesystem::path>& redfishLogFiles)
Jason M. Bills95820182019-04-22 16:25:34 -0700288{
289 static const std::filesystem::path redfishLogDir = "/var/log";
290 static const std::string redfishLogFilename = "redfish";
291
292 // Loop through the directory looking for redfish log files
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500293 for (const std::filesystem::directory_entry& dirEnt :
Jason M. Bills95820182019-04-22 16:25:34 -0700294 std::filesystem::directory_iterator(redfishLogDir))
295 {
296 // If we find a redfish log file, save the path
297 std::string filename = dirEnt.path().filename();
Ed Tanous11ba3972022-07-11 09:50:41 -0700298 if (filename.starts_with(redfishLogFilename))
Jason M. Bills95820182019-04-22 16:25:34 -0700299 {
300 redfishLogFiles.emplace_back(redfishLogDir / filename);
301 }
302 }
303 // As the log files rotate, they are appended with a ".#" that is higher for
304 // the older logs. Since we don't expect more than 10 log files, we
305 // can just sort the list to get them in order from newest to oldest
Ed Tanous3544d2a2023-08-06 18:12:20 -0700306 std::ranges::sort(redfishLogFiles);
Jason M. Bills95820182019-04-22 16:25:34 -0700307
308 return !redfishLogFiles.empty();
309}
310
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600311inline log_entry::OriginatorTypes
312 mapDbusOriginatorTypeToRedfish(const std::string& originatorType)
313{
314 if (originatorType ==
315 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.Client")
316 {
317 return log_entry::OriginatorTypes::Client;
318 }
319 if (originatorType ==
320 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.Internal")
321 {
322 return log_entry::OriginatorTypes::Internal;
323 }
324 if (originatorType ==
325 "xyz.openbmc_project.Common.OriginatedBy.OriginatorTypes.SupportingService")
326 {
327 return log_entry::OriginatorTypes::SupportingService;
328 }
329 return log_entry::OriginatorTypes::Invalid;
330}
331
Claire Weinanaefe3782022-07-15 19:17:19 -0700332inline void parseDumpEntryFromDbusObject(
Jiaqing Zhao2d613eb2022-08-15 16:03:00 +0800333 const dbus::utility::ManagedObjectType::value_type& object,
Claire Weinanc6fecda2022-07-15 10:43:25 -0700334 std::string& dumpStatus, uint64_t& size, uint64_t& timestampUs,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600335 std::string& originatorId, log_entry::OriginatorTypes& originatorType,
Claire Weinanaefe3782022-07-15 19:17:19 -0700336 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
337{
338 for (const auto& interfaceMap : object.second)
339 {
340 if (interfaceMap.first == "xyz.openbmc_project.Common.Progress")
341 {
342 for (const auto& propertyMap : interfaceMap.second)
343 {
344 if (propertyMap.first == "Status")
345 {
346 const auto* status =
347 std::get_if<std::string>(&propertyMap.second);
348 if (status == nullptr)
349 {
350 messages::internalError(asyncResp->res);
351 break;
352 }
353 dumpStatus = *status;
354 }
355 }
356 }
357 else if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
358 {
359 for (const auto& propertyMap : interfaceMap.second)
360 {
361 if (propertyMap.first == "Size")
362 {
363 const auto* sizePtr =
364 std::get_if<uint64_t>(&propertyMap.second);
365 if (sizePtr == nullptr)
366 {
367 messages::internalError(asyncResp->res);
368 break;
369 }
370 size = *sizePtr;
371 break;
372 }
373 }
374 }
375 else if (interfaceMap.first == "xyz.openbmc_project.Time.EpochTime")
376 {
377 for (const auto& propertyMap : interfaceMap.second)
378 {
379 if (propertyMap.first == "Elapsed")
380 {
381 const uint64_t* usecsTimeStamp =
382 std::get_if<uint64_t>(&propertyMap.second);
383 if (usecsTimeStamp == nullptr)
384 {
385 messages::internalError(asyncResp->res);
386 break;
387 }
Claire Weinanc6fecda2022-07-15 10:43:25 -0700388 timestampUs = *usecsTimeStamp;
Claire Weinanaefe3782022-07-15 19:17:19 -0700389 break;
390 }
391 }
392 }
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600393 else if (interfaceMap.first ==
394 "xyz.openbmc_project.Common.OriginatedBy")
395 {
396 for (const auto& propertyMap : interfaceMap.second)
397 {
398 if (propertyMap.first == "OriginatorId")
399 {
400 const std::string* id =
401 std::get_if<std::string>(&propertyMap.second);
402 if (id == nullptr)
403 {
404 messages::internalError(asyncResp->res);
405 break;
406 }
407 originatorId = *id;
408 }
409
410 if (propertyMap.first == "OriginatorType")
411 {
412 const std::string* type =
413 std::get_if<std::string>(&propertyMap.second);
414 if (type == nullptr)
415 {
416 messages::internalError(asyncResp->res);
417 break;
418 }
419
420 originatorType = mapDbusOriginatorTypeToRedfish(*type);
421 if (originatorType == log_entry::OriginatorTypes::Invalid)
422 {
423 messages::internalError(asyncResp->res);
424 break;
425 }
426 }
427 }
428 }
Claire Weinanaefe3782022-07-15 19:17:19 -0700429 }
430}
431
Nan Zhou21ab4042022-06-26 23:07:40 +0000432static std::string getDumpEntriesPath(const std::string& dumpType)
Claire Weinanfdd26902022-03-01 14:18:25 -0800433{
434 std::string entriesPath;
435
436 if (dumpType == "BMC")
437 {
438 entriesPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
439 }
440 else if (dumpType == "FaultLog")
441 {
442 entriesPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/";
443 }
444 else if (dumpType == "System")
445 {
446 entriesPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
447 }
448 else
449 {
Ed Tanous62598e32023-07-17 17:06:25 -0700450 BMCWEB_LOG_ERROR("getDumpEntriesPath() invalid dump type: {}",
451 dumpType);
Claire Weinanfdd26902022-03-01 14:18:25 -0800452 }
453
454 // Returns empty string on error
455 return entriesPath;
456}
457
zhanghch058d1b46d2021-04-01 11:18:24 +0800458inline void
459 getDumpEntryCollection(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
460 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500461{
Claire Weinanfdd26902022-03-01 14:18:25 -0800462 std::string entriesPath = getDumpEntriesPath(dumpType);
463 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500464 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500465 messages::internalError(asyncResp->res);
466 return;
467 }
468
George Liu5eb468d2023-06-20 17:03:24 +0800469 sdbusplus::message::object_path path("/xyz/openbmc_project/dump");
470 dbus::utility::getManagedObjects(
471 "xyz.openbmc_project.Dump.Manager", path,
Claire Weinanfdd26902022-03-01 14:18:25 -0800472 [asyncResp, entriesPath,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800473 dumpType](const boost::system::error_code& ec,
George Liu5eb468d2023-06-20 17:03:24 +0800474 const dbus::utility::ManagedObjectType& objects) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700475 if (ec)
476 {
Ed Tanous62598e32023-07-17 17:06:25 -0700477 BMCWEB_LOG_ERROR("DumpEntry resp_handler got error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -0700478 messages::internalError(asyncResp->res);
479 return;
480 }
481
Claire Weinanfdd26902022-03-01 14:18:25 -0800482 // Remove ending slash
483 std::string odataIdStr = entriesPath;
484 if (!odataIdStr.empty())
485 {
486 odataIdStr.pop_back();
487 }
488
489 asyncResp->res.jsonValue["@odata.type"] =
490 "#LogEntryCollection.LogEntryCollection";
491 asyncResp->res.jsonValue["@odata.id"] = std::move(odataIdStr);
492 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entries";
Patrick Williams89492a12023-05-10 07:51:34 -0500493 asyncResp->res.jsonValue["Description"] = "Collection of " + dumpType +
494 " Dump Entries";
Claire Weinanfdd26902022-03-01 14:18:25 -0800495
Ed Tanous3544d2a2023-08-06 18:12:20 -0700496 nlohmann::json::array_t entriesArray;
Ed Tanous002d39b2022-05-31 08:59:27 -0700497 std::string dumpEntryPath =
498 "/xyz/openbmc_project/dump/" +
499 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
500
George Liu5eb468d2023-06-20 17:03:24 +0800501 dbus::utility::ManagedObjectType resp(objects);
Ed Tanous3544d2a2023-08-06 18:12:20 -0700502 std::ranges::sort(resp, [](const auto& l, const auto& r) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700503 return AlphanumLess<std::string>()(l.first.filename(),
504 r.first.filename());
505 });
506
507 for (auto& object : resp)
508 {
509 if (object.first.str.find(dumpEntryPath) == std::string::npos)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500510 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700511 continue;
512 }
Claire Weinanc6fecda2022-07-15 10:43:25 -0700513 uint64_t timestampUs = 0;
Ed Tanous002d39b2022-05-31 08:59:27 -0700514 uint64_t size = 0;
515 std::string dumpStatus;
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600516 std::string originatorId;
517 log_entry::OriginatorTypes originatorType =
518 log_entry::OriginatorTypes::Internal;
Jason M. Bills433b68b2022-06-28 12:24:26 -0700519 nlohmann::json::object_t thisEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -0700520
521 std::string entryID = object.first.filename();
522 if (entryID.empty())
523 {
524 continue;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500525 }
526
Claire Weinanc6fecda2022-07-15 10:43:25 -0700527 parseDumpEntryFromDbusObject(object, dumpStatus, size, timestampUs,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600528 originatorId, originatorType,
Claire Weinanaefe3782022-07-15 19:17:19 -0700529 asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -0700530
531 if (dumpStatus !=
532 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
533 !dumpStatus.empty())
534 {
535 // Dump status is not Complete, no need to enumerate
536 continue;
537 }
538
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600539 thisEntry["@odata.type"] = "#LogEntry.v1_11_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800540 thisEntry["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700541 thisEntry["Id"] = entryID;
542 thisEntry["EntryType"] = "Event";
Ed Tanous002d39b2022-05-31 08:59:27 -0700543 thisEntry["Name"] = dumpType + " Dump Entry";
Claire Weinanbbd80db2022-10-26 16:55:52 -0700544 thisEntry["Created"] =
545 redfish::time_utils::getDateTimeUintUs(timestampUs);
Ed Tanous002d39b2022-05-31 08:59:27 -0700546
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600547 if (!originatorId.empty())
548 {
549 thisEntry["Originator"] = originatorId;
550 thisEntry["OriginatorType"] = originatorType;
551 }
552
Ed Tanous002d39b2022-05-31 08:59:27 -0700553 if (dumpType == "BMC")
554 {
555 thisEntry["DiagnosticDataType"] = "Manager";
Patrick Williams89492a12023-05-10 07:51:34 -0500556 thisEntry["AdditionalDataURI"] = entriesPath + entryID +
557 "/attachment";
Claire Weinanfdd26902022-03-01 14:18:25 -0800558 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700559 }
560 else if (dumpType == "System")
561 {
562 thisEntry["DiagnosticDataType"] = "OEM";
563 thisEntry["OEMDiagnosticDataType"] = "System";
Patrick Williams89492a12023-05-10 07:51:34 -0500564 thisEntry["AdditionalDataURI"] = entriesPath + entryID +
565 "/attachment";
Claire Weinanfdd26902022-03-01 14:18:25 -0800566 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700567 }
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500568 entriesArray.emplace_back(std::move(thisEntry));
Ed Tanous002d39b2022-05-31 08:59:27 -0700569 }
570 asyncResp->res.jsonValue["Members@odata.count"] = entriesArray.size();
Ed Tanous3544d2a2023-08-06 18:12:20 -0700571 asyncResp->res.jsonValue["Members"] = std::move(entriesArray);
George Liu5eb468d2023-06-20 17:03:24 +0800572 });
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500573}
574
zhanghch058d1b46d2021-04-01 11:18:24 +0800575inline void
Claire Weinanc7a6d662022-06-13 16:36:39 -0700576 getDumpEntryById(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
zhanghch058d1b46d2021-04-01 11:18:24 +0800577 const std::string& entryID, const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500578{
Claire Weinanfdd26902022-03-01 14:18:25 -0800579 std::string entriesPath = getDumpEntriesPath(dumpType);
580 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500581 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500582 messages::internalError(asyncResp->res);
583 return;
584 }
585
George Liu5eb468d2023-06-20 17:03:24 +0800586 sdbusplus::message::object_path path("/xyz/openbmc_project/dump");
587 dbus::utility::getManagedObjects(
588 "xyz.openbmc_project.Dump.Manager", path,
Claire Weinanfdd26902022-03-01 14:18:25 -0800589 [asyncResp, entryID, dumpType,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800590 entriesPath](const boost::system::error_code& ec,
Ed Tanous02cad962022-06-30 16:50:15 -0700591 const dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700592 if (ec)
593 {
Ed Tanous62598e32023-07-17 17:06:25 -0700594 BMCWEB_LOG_ERROR("DumpEntry resp_handler got error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -0700595 messages::internalError(asyncResp->res);
596 return;
597 }
598
599 bool foundDumpEntry = false;
600 std::string dumpEntryPath =
601 "/xyz/openbmc_project/dump/" +
602 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
603
604 for (const auto& objectPath : resp)
605 {
606 if (objectPath.first.str != dumpEntryPath + entryID)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500607 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700608 continue;
609 }
610
611 foundDumpEntry = true;
Claire Weinanc6fecda2022-07-15 10:43:25 -0700612 uint64_t timestampUs = 0;
Ed Tanous002d39b2022-05-31 08:59:27 -0700613 uint64_t size = 0;
614 std::string dumpStatus;
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600615 std::string originatorId;
616 log_entry::OriginatorTypes originatorType =
617 log_entry::OriginatorTypes::Internal;
Ed Tanous002d39b2022-05-31 08:59:27 -0700618
Claire Weinanaefe3782022-07-15 19:17:19 -0700619 parseDumpEntryFromDbusObject(objectPath, dumpStatus, size,
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600620 timestampUs, originatorId,
621 originatorType, asyncResp);
Ed Tanous002d39b2022-05-31 08:59:27 -0700622
623 if (dumpStatus !=
624 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
625 !dumpStatus.empty())
626 {
627 // Dump status is not Complete
628 // return not found until status is changed to Completed
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +0200629 messages::resourceNotFound(asyncResp->res, dumpType + " dump",
630 entryID);
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500631 return;
632 }
633
Ed Tanous002d39b2022-05-31 08:59:27 -0700634 asyncResp->res.jsonValue["@odata.type"] =
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600635 "#LogEntry.v1_11_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800636 asyncResp->res.jsonValue["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700637 asyncResp->res.jsonValue["Id"] = entryID;
638 asyncResp->res.jsonValue["EntryType"] = "Event";
Ed Tanous002d39b2022-05-31 08:59:27 -0700639 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entry";
Claire Weinanbbd80db2022-10-26 16:55:52 -0700640 asyncResp->res.jsonValue["Created"] =
641 redfish::time_utils::getDateTimeUintUs(timestampUs);
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500642
Asmitha Karunanithi68dd0752022-11-15 11:33:46 -0600643 if (!originatorId.empty())
644 {
645 asyncResp->res.jsonValue["Originator"] = originatorId;
646 asyncResp->res.jsonValue["OriginatorType"] = originatorType;
647 }
648
Ed Tanous002d39b2022-05-31 08:59:27 -0700649 if (dumpType == "BMC")
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500650 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700651 asyncResp->res.jsonValue["DiagnosticDataType"] = "Manager";
652 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800653 entriesPath + entryID + "/attachment";
654 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500655 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700656 else if (dumpType == "System")
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500657 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700658 asyncResp->res.jsonValue["DiagnosticDataType"] = "OEM";
659 asyncResp->res.jsonValue["OEMDiagnosticDataType"] = "System";
660 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800661 entriesPath + entryID + "/attachment";
662 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500663 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700664 }
665 if (!foundDumpEntry)
666 {
Ed Tanous62598e32023-07-17 17:06:25 -0700667 BMCWEB_LOG_WARNING("Can't find Dump Entry {}", entryID);
Myung Baeb90d14f2023-05-31 14:40:39 -0500668 messages::resourceNotFound(asyncResp->res, dumpType + " dump",
669 entryID);
Ed Tanous002d39b2022-05-31 08:59:27 -0700670 return;
671 }
George Liu5eb468d2023-06-20 17:03:24 +0800672 });
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500673}
674
zhanghch058d1b46d2021-04-01 11:18:24 +0800675inline void deleteDumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Stanley Chu98782562020-11-04 16:10:24 +0800676 const std::string& entryID,
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500677 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500678{
Ed Tanous002d39b2022-05-31 08:59:27 -0700679 auto respHandler =
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800680 [asyncResp, entryID](const boost::system::error_code& ec) {
Ed Tanous62598e32023-07-17 17:06:25 -0700681 BMCWEB_LOG_DEBUG("Dump Entry doDelete callback: Done");
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500682 if (ec)
683 {
George Liu3de8d8b2021-03-22 17:49:39 +0800684 if (ec.value() == EBADR)
685 {
686 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
687 return;
688 }
Ed Tanous62598e32023-07-17 17:06:25 -0700689 BMCWEB_LOG_ERROR(
690 "Dump (DBus) doDelete respHandler got error {} entryID={}", ec,
691 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700731 BMCWEB_LOG_ERROR("Status property value is null");
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600732 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700765 BMCWEB_LOG_ERROR("Invalid dump type received");
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600766 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700777 BMCWEB_LOG_ERROR("Introspect call failed with error: {}",
778 ec.message());
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600779 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700793 BMCWEB_LOG_ERROR("XML document failed to parse");
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600794 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 Tanous8b242752023-06-27 17:17:13 -0700821 const boost::system::error_code& ec2, sdbusplus::message_t& msg,
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600822 const std::shared_ptr<task::TaskData>& taskData) {
Ed Tanous8b242752023-06-27 17:17:13 -0700823 if (ec2)
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600824 {
Ed Tanous62598e32023-07-17 17:06:25 -0700825 BMCWEB_LOG_ERROR("{}: Error in creating dump",
826 createdObjPath.str);
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600827 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700842 BMCWEB_LOG_ERROR("{}: Error in creating dump",
843 createdObjPath.str);
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600844 taskData->state = "Cancelled";
845 return task::completed;
846 }
847
848 if (dumpStatus == DumpCreationProgress::DUMP_CREATE_INPROGRESS)
849 {
Ed Tanous62598e32023-07-17 17:06:25 -0700850 BMCWEB_LOG_DEBUG("{}: Dump creation task is in progress",
851 createdObjPath.str);
Asmitha Karunanithi8e317782020-12-10 03:35:05 -0600852 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
Ed Tanous62598e32023-07-17 17:06:25 -0700867 BMCWEB_LOG_DEBUG("{}: Dump creation task completed",
868 createdObjPath.str);
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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700910 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700920 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700930 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700938 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700947 BMCWEB_LOG_ERROR("CreateDump failed. Unknown dump type");
Asmitha Karunanithi59075712021-10-22 01:17:41 -0500948 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 {
Ed Tanous62598e32023-07-17 17:06:25 -0700972 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
Ed Tanous62598e32023-07-17 17:06:25 -0700980 BMCWEB_LOG_ERROR("CreateDump DBus error: {} and error msg: {}",
981 dbusError->name, dbusError->message);
Asmitha Karunanithi59075712021-10-22 01:17:41 -0500982 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 }
Ed Tanous62598e32023-07-17 17:06:25 -07001013 BMCWEB_LOG_DEBUG("Dump Created. Path: {}", objPath.str);
Asmitha Karunanithi8e317782020-12-10 03:35:05 -06001014 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 {
Ed Tanous62598e32023-07-17 17:06:25 -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 Tanous7f3e84a2022-12-28 16:22:54 -08001091 if constexpr (bmcwebEnableMultiHost)
1092 {
1093 // Option currently returns no systems. TBD
1094 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1095 systemName);
1096 return;
1097 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001098 if (systemName != "system")
1099 {
1100 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1101 systemName);
1102 return;
1103 }
1104
Ed Tanous002d39b2022-05-31 08:59:27 -07001105 // Collections don't include the static data added by SubRoute
1106 // because it has a duplicate entry for members
1107 asyncResp->res.jsonValue["@odata.type"] =
1108 "#LogServiceCollection.LogServiceCollection";
1109 asyncResp->res.jsonValue["@odata.id"] =
1110 "/redfish/v1/Systems/system/LogServices";
1111 asyncResp->res.jsonValue["Name"] = "System Log Services Collection";
1112 asyncResp->res.jsonValue["Description"] =
1113 "Collection of LogServices for this Computer System";
1114 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
1115 logServiceArray = nlohmann::json::array();
1116 nlohmann::json::object_t eventLog;
1117 eventLog["@odata.id"] =
1118 "/redfish/v1/Systems/system/LogServices/EventLog";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001119 logServiceArray.emplace_back(std::move(eventLog));
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05001120#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -07001121 nlohmann::json::object_t dumpLog;
1122 dumpLog["@odata.id"] = "/redfish/v1/Systems/system/LogServices/Dump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001123 logServiceArray.emplace_back(std::move(dumpLog));
raviteja-bc9bb6862020-02-03 11:53:32 -06001124#endif
1125
Jason M. Billsd53dd412019-02-12 17:16:22 -08001126#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -07001127 nlohmann::json::object_t crashdump;
1128 crashdump["@odata.id"] =
1129 "/redfish/v1/Systems/system/LogServices/Crashdump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001130 logServiceArray.emplace_back(std::move(crashdump));
Jason M. Billsd53dd412019-02-12 17:16:22 -08001131#endif
Spencer Kub7028eb2021-10-26 15:27:35 +08001132
1133#ifdef BMCWEB_ENABLE_REDFISH_HOST_LOGGER
Ed Tanous002d39b2022-05-31 08:59:27 -07001134 nlohmann::json::object_t hostlogger;
1135 hostlogger["@odata.id"] =
1136 "/redfish/v1/Systems/system/LogServices/HostLogger";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001137 logServiceArray.emplace_back(std::move(hostlogger));
Spencer Kub7028eb2021-10-26 15:27:35 +08001138#endif
Ed Tanous002d39b2022-05-31 08:59:27 -07001139 asyncResp->res.jsonValue["Members@odata.count"] =
1140 logServiceArray.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -08001141
George Liu7a1dbc42022-12-07 16:03:22 +08001142 constexpr std::array<std::string_view, 1> interfaces = {
1143 "xyz.openbmc_project.State.Boot.PostCode"};
1144 dbus::utility::getSubTreePaths(
1145 "/", 0, interfaces,
1146 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001147 const dbus::utility::MapperGetSubTreePathsResponse&
1148 subtreePath) {
1149 if (ec)
1150 {
Ed Tanous62598e32023-07-17 17:06:25 -07001151 BMCWEB_LOG_ERROR("{}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001152 return;
1153 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07001154
Ed Tanous002d39b2022-05-31 08:59:27 -07001155 for (const auto& pathStr : subtreePath)
1156 {
1157 if (pathStr.find("PostCode") != std::string::npos)
1158 {
1159 nlohmann::json& logServiceArrayLocal =
1160 asyncResp->res.jsonValue["Members"];
Ed Tanous613dabe2022-07-09 11:17:36 -07001161 nlohmann::json::object_t member;
1162 member["@odata.id"] =
1163 "/redfish/v1/Systems/system/LogServices/PostCodes";
1164
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001165 logServiceArrayLocal.emplace_back(std::move(member));
Ed Tanous613dabe2022-07-09 11:17:36 -07001166
Ed Tanous002d39b2022-05-31 08:59:27 -07001167 asyncResp->res.jsonValue["Members@odata.count"] =
1168 logServiceArrayLocal.size();
1169 return;
1170 }
1171 }
George Liu7a1dbc42022-12-07 16:03:22 +08001172 });
Ed Tanous45ca1b82022-03-25 13:07:27 -07001173 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001174}
1175
1176inline void requestRoutesEventLogService(App& app)
1177{
Ed Tanous22d268c2022-05-19 09:39:07 -07001178 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/")
Ed Tanoused398212021-06-09 17:05:54 -07001179 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07001180 .methods(boost::beast::http::verb::get)(
1181 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001182 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1183 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001184 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001185 {
1186 return;
1187 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001188 if (systemName != "system")
1189 {
1190 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1191 systemName);
1192 return;
1193 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001194 asyncResp->res.jsonValue["@odata.id"] =
1195 "/redfish/v1/Systems/system/LogServices/EventLog";
1196 asyncResp->res.jsonValue["@odata.type"] =
1197 "#LogService.v1_1_0.LogService";
1198 asyncResp->res.jsonValue["Name"] = "Event Log Service";
1199 asyncResp->res.jsonValue["Description"] = "System Event Log Service";
1200 asyncResp->res.jsonValue["Id"] = "EventLog";
1201 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05301202
Ed Tanous002d39b2022-05-31 08:59:27 -07001203 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07001204 redfish::time_utils::getDateTimeOffsetNow();
Tejas Patil7c8c4052021-06-04 17:43:14 +05301205
Ed Tanous002d39b2022-05-31 08:59:27 -07001206 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
1207 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
1208 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05301209
Ed Tanous002d39b2022-05-31 08:59:27 -07001210 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
1211 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1212 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001213
Ed Tanous002d39b2022-05-31 08:59:27 -07001214 {"target",
1215 "/redfish/v1/Systems/system/LogServices/EventLog/Actions/LogService.ClearLog"}};
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001216 });
1217}
1218
1219inline void requestRoutesJournalEventLogClear(App& app)
1220{
Jason M. Bills4978b632022-02-22 14:17:43 -08001221 BMCWEB_ROUTE(
1222 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07001223 "/redfish/v1/Systems/<str>/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanous432a8902021-06-14 15:28:56 -07001224 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001225 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001226 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001227 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1228 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001229 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001230 {
1231 return;
1232 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001233 if (systemName != "system")
1234 {
1235 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1236 systemName);
1237 return;
1238 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001239 // Clear the EventLog by deleting the log files
1240 std::vector<std::filesystem::path> redfishLogFiles;
1241 if (getRedfishLogFiles(redfishLogFiles))
1242 {
1243 for (const std::filesystem::path& file : redfishLogFiles)
1244 {
1245 std::error_code ec;
1246 std::filesystem::remove(file, ec);
1247 }
1248 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001249
Ed Tanous002d39b2022-05-31 08:59:27 -07001250 // Reload rsyslog so it knows to start new log files
1251 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001252 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001253 if (ec)
1254 {
Ed Tanous62598e32023-07-17 17:06:25 -07001255 BMCWEB_LOG_ERROR("Failed to reload rsyslog: {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001256 messages::internalError(asyncResp->res);
1257 return;
1258 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001259
Ed Tanous002d39b2022-05-31 08:59:27 -07001260 messages::success(asyncResp->res);
1261 },
1262 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1263 "org.freedesktop.systemd1.Manager", "ReloadUnit", "rsyslog.service",
1264 "replace");
1265 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001266}
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001267
Jason M. Billsac992cd2022-06-24 13:31:46 -07001268enum class LogParseError
1269{
1270 success,
1271 parseFailed,
1272 messageIdNotInRegistry,
1273};
1274
1275static LogParseError
1276 fillEventLogEntryJson(const std::string& logEntryID,
1277 const std::string& logEntry,
1278 nlohmann::json::object_t& logEntryJson)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001279{
Jason M. Bills95820182019-04-22 16:25:34 -07001280 // The redfish log format is "<Timestamp> <MessageId>,<MessageArgs>"
Jason M. Billscd225da2019-05-08 15:31:57 -07001281 // First get the Timestamp
Ed Tanousf23b7292020-10-15 09:41:17 -07001282 size_t space = logEntry.find_first_of(' ');
Jason M. Billscd225da2019-05-08 15:31:57 -07001283 if (space == std::string::npos)
Jason M. Bills95820182019-04-22 16:25:34 -07001284 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001285 return LogParseError::parseFailed;
Jason M. Bills95820182019-04-22 16:25:34 -07001286 }
Jason M. Billscd225da2019-05-08 15:31:57 -07001287 std::string timestamp = logEntry.substr(0, space);
1288 // Then get the log contents
Ed Tanousf23b7292020-10-15 09:41:17 -07001289 size_t entryStart = logEntry.find_first_not_of(' ', space);
Jason M. Billscd225da2019-05-08 15:31:57 -07001290 if (entryStart == std::string::npos)
1291 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001292 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001293 }
1294 std::string_view entry(logEntry);
1295 entry.remove_prefix(entryStart);
1296 // Use split to separate the entry into its fields
1297 std::vector<std::string> logEntryFields;
Ed Tanous50ebd4a2023-01-19 19:03:17 -08001298 bmcweb::split(logEntryFields, entry, ',');
Jason M. Billscd225da2019-05-08 15:31:57 -07001299 // We need at least a MessageId to be valid
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001300 auto logEntryIter = logEntryFields.begin();
1301 if (logEntryIter == logEntryFields.end())
Jason M. Billscd225da2019-05-08 15:31:57 -07001302 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001303 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001304 }
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001305 std::string& messageID = *logEntryIter;
Jason M. Bills4851d452019-03-28 11:27:48 -07001306 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08001307 const registries::Message* message = registries::getMessage(messageID);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001308
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001309 logEntryIter++;
Sui Chen54417b02022-03-24 14:59:52 -07001310 if (message == nullptr)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001311 {
Ed Tanous62598e32023-07-17 17:06:25 -07001312 BMCWEB_LOG_WARNING("Log entry not found in registry: {}", logEntry);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001313 return LogParseError::messageIdNotInRegistry;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001314 }
1315
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001316 std::vector<std::string_view> messageArgs(logEntryIter,
1317 logEntryFields.end());
Ed Tanousc05bba42023-06-28 08:33:29 -07001318 messageArgs.resize(message->numberOfArgs);
1319
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001320 std::string msg = redfish::registries::fillMessageArgs(messageArgs,
1321 message->message);
1322 if (msg.empty())
Jason M. Bills4851d452019-03-28 11:27:48 -07001323 {
Ed Tanous1e6deaf2022-02-17 11:32:37 -08001324 return LogParseError::parseFailed;
Jason M. Bills4851d452019-03-28 11:27:48 -07001325 }
1326
Jason M. Bills95820182019-04-22 16:25:34 -07001327 // Get the Created time from the timestamp. The log timestamp is in RFC3339
1328 // format which matches the Redfish format except for the fractional seconds
1329 // between the '.' and the '+', so just remove them.
Ed Tanousf23b7292020-10-15 09:41:17 -07001330 std::size_t dot = timestamp.find_first_of('.');
1331 std::size_t plus = timestamp.find_first_of('+');
Jason M. Bills95820182019-04-22 16:25:34 -07001332 if (dot != std::string::npos && plus != std::string::npos)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001333 {
Jason M. Bills95820182019-04-22 16:25:34 -07001334 timestamp.erase(dot, plus - dot);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001335 }
1336
1337 // Fill in the log entry with the gathered data
Vijay Lobo9c11a172021-10-07 16:53:16 -05001338 logEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001339 logEntryJson["@odata.id"] = boost::urls::format(
1340 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1341 logEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07001342 logEntryJson["Name"] = "System Event Log Entry";
1343 logEntryJson["Id"] = logEntryID;
1344 logEntryJson["Message"] = std::move(msg);
1345 logEntryJson["MessageId"] = std::move(messageID);
1346 logEntryJson["MessageArgs"] = messageArgs;
1347 logEntryJson["EntryType"] = "Event";
1348 logEntryJson["Severity"] = message->messageSeverity;
1349 logEntryJson["Created"] = std::move(timestamp);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001350 return LogParseError::success;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001351}
1352
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001353inline void requestRoutesJournalEventLogEntryCollection(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001354{
Ed Tanous22d268c2022-05-19 09:39:07 -07001355 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/")
Gunnar Mills8b6a35f2021-07-30 14:52:53 -05001356 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001357 .methods(boost::beast::http::verb::get)(
1358 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001359 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1360 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001361 query_param::QueryCapabilities capabilities = {
1362 .canDelegateTop = true,
1363 .canDelegateSkip = true,
1364 };
1365 query_param::Query delegatedQuery;
1366 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00001367 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07001368 {
1369 return;
1370 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001371 if constexpr (bmcwebEnableMultiHost)
1372 {
1373 // Option currently returns no systems. TBD
1374 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1375 systemName);
1376 return;
1377 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001378 if (systemName != "system")
1379 {
1380 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1381 systemName);
1382 return;
1383 }
1384
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08001385 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07001386 size_t skip = delegatedQuery.skip.value_or(0);
1387
Ed Tanous002d39b2022-05-31 08:59:27 -07001388 // Collections don't include the static data added by SubRoute
1389 // because it has a duplicate entry for members
1390 asyncResp->res.jsonValue["@odata.type"] =
1391 "#LogEntryCollection.LogEntryCollection";
1392 asyncResp->res.jsonValue["@odata.id"] =
1393 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1394 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1395 asyncResp->res.jsonValue["Description"] =
1396 "Collection of System Event Log Entries";
1397
1398 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
1399 logEntryArray = nlohmann::json::array();
1400 // Go through the log files and create a unique ID for each
1401 // entry
1402 std::vector<std::filesystem::path> redfishLogFiles;
1403 getRedfishLogFiles(redfishLogFiles);
1404 uint64_t entryCount = 0;
1405 std::string logEntry;
1406
1407 // Oldest logs are in the last file, so start there and loop
1408 // backwards
1409 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1410 it++)
1411 {
1412 std::ifstream logStream(*it);
1413 if (!logStream.is_open())
Jason M. Bills4978b632022-02-22 14:17:43 -08001414 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001415 continue;
Jason M. Bills4978b632022-02-22 14:17:43 -08001416 }
Jason M. Bills897967d2019-07-29 17:05:30 -07001417
Ed Tanous002d39b2022-05-31 08:59:27 -07001418 // Reset the unique ID on the first entry
1419 bool firstEntry = true;
1420 while (std::getline(logStream, logEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001421 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001422 std::string idStr;
1423 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001424 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001425 continue;
1426 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001427 firstEntry = false;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001428
Jason M. Billsde703c52022-06-23 14:19:04 -07001429 nlohmann::json::object_t bmcLogEntry;
Patrick Williams89492a12023-05-10 07:51:34 -05001430 LogParseError status = fillEventLogEntryJson(idStr, logEntry,
1431 bmcLogEntry);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001432 if (status == LogParseError::messageIdNotInRegistry)
1433 {
1434 continue;
1435 }
1436 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001437 {
1438 messages::internalError(asyncResp->res);
1439 return;
Andrew Geisslercb92c032018-08-17 07:56:14 -07001440 }
Jason M. Billsde703c52022-06-23 14:19:04 -07001441
Jason M. Billsde703c52022-06-23 14:19:04 -07001442 entryCount++;
1443 // Handle paging using skip (number of entries to skip from the
1444 // start) and top (number of entries to display)
Ed Tanous3648c8b2022-07-25 13:39:59 -07001445 if (entryCount <= skip || entryCount > skip + top)
Jason M. Billsde703c52022-06-23 14:19:04 -07001446 {
1447 continue;
1448 }
1449
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001450 logEntryArray.emplace_back(std::move(bmcLogEntry));
Jason M. Bills4978b632022-02-22 14:17:43 -08001451 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001452 }
1453 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07001454 if (skip + top < entryCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07001455 {
1456 asyncResp->res.jsonValue["Members@odata.nextLink"] =
1457 "/redfish/v1/Systems/system/LogServices/EventLog/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07001458 std::to_string(skip + top);
Ed Tanous002d39b2022-05-31 08:59:27 -07001459 }
Jason M. Bills4978b632022-02-22 14:17:43 -08001460 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001461}
Chicago Duan336e96c2019-07-15 14:22:08 +08001462
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001463inline void requestRoutesJournalEventLogEntry(App& app)
1464{
1465 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001466 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001467 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001468 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001469 [&app](const crow::Request& req,
1470 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001471 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001472 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001473 {
1474 return;
1475 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001476 if constexpr (bmcwebEnableMultiHost)
1477 {
1478 // Option currently returns no systems. TBD
1479 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1480 systemName);
1481 return;
1482 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001483
1484 if (systemName != "system")
1485 {
1486 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1487 systemName);
1488 return;
1489 }
1490
Ed Tanous002d39b2022-05-31 08:59:27 -07001491 const std::string& targetID = param;
1492
1493 // Go through the log files and check the unique ID for each
1494 // entry to find the target entry
1495 std::vector<std::filesystem::path> redfishLogFiles;
1496 getRedfishLogFiles(redfishLogFiles);
1497 std::string logEntry;
1498
1499 // Oldest logs are in the last file, so start there and loop
1500 // backwards
1501 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1502 it++)
1503 {
1504 std::ifstream logStream(*it);
1505 if (!logStream.is_open())
1506 {
1507 continue;
1508 }
1509
1510 // Reset the unique ID on the first entry
1511 bool firstEntry = true;
1512 while (std::getline(logStream, logEntry))
1513 {
1514 std::string idStr;
1515 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Ed Tanous45ca1b82022-03-25 13:07:27 -07001516 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001517 continue;
1518 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001519 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07001520
1521 if (idStr == targetID)
1522 {
Jason M. Billsde703c52022-06-23 14:19:04 -07001523 nlohmann::json::object_t bmcLogEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001524 LogParseError status =
1525 fillEventLogEntryJson(idStr, logEntry, bmcLogEntry);
1526 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001527 {
1528 messages::internalError(asyncResp->res);
1529 return;
1530 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07001531 asyncResp->res.jsonValue.update(bmcLogEntry);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001532 return;
1533 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001534 }
1535 }
1536 // Requested ID was not found
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08001537 messages::resourceNotFound(asyncResp->res, "LogEntry", targetID);
Ed Tanous002d39b2022-05-31 08:59:27 -07001538 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001539}
1540
1541inline void requestRoutesDBusEventLogEntryCollection(App& app)
1542{
Ed Tanous22d268c2022-05-19 09:39:07 -07001543 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07001544 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001545 .methods(boost::beast::http::verb::get)(
1546 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001547 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1548 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001549 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001550 {
1551 return;
1552 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001553 if constexpr (bmcwebEnableMultiHost)
1554 {
1555 // Option currently returns no systems. TBD
1556 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1557 systemName);
1558 return;
1559 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001560 if (systemName != "system")
1561 {
1562 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1563 systemName);
1564 return;
1565 }
1566
Ed Tanous002d39b2022-05-31 08:59:27 -07001567 // Collections don't include the static data added by SubRoute
1568 // because it has a duplicate entry for members
1569 asyncResp->res.jsonValue["@odata.type"] =
1570 "#LogEntryCollection.LogEntryCollection";
1571 asyncResp->res.jsonValue["@odata.id"] =
1572 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1573 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1574 asyncResp->res.jsonValue["Description"] =
1575 "Collection of System Event Log Entries";
1576
1577 // DBus implementation of EventLog/Entries
1578 // Make call to Logging Service to find all log entry objects
George Liu5eb468d2023-06-20 17:03:24 +08001579 sdbusplus::message::object_path path("/xyz/openbmc_project/logging");
1580 dbus::utility::getManagedObjects(
1581 "xyz.openbmc_project.Logging", path,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001582 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001583 const dbus::utility::ManagedObjectType& resp) {
1584 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001585 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001586 // TODO Handle for specific error code
Ed Tanous62598e32023-07-17 17:06:25 -07001587 BMCWEB_LOG_ERROR(
1588 "getLogEntriesIfaceData resp_handler got error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001589 messages::internalError(asyncResp->res);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001590 return;
1591 }
Ed Tanous3544d2a2023-08-06 18:12:20 -07001592 nlohmann::json::array_t entriesArray;
Ed Tanous002d39b2022-05-31 08:59:27 -07001593 for (const auto& objectPath : resp)
1594 {
1595 const uint32_t* id = nullptr;
1596 const uint64_t* timestamp = nullptr;
1597 const uint64_t* updateTimestamp = nullptr;
1598 const std::string* severity = nullptr;
1599 const std::string* message = nullptr;
1600 const std::string* filePath = nullptr;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001601 const std::string* resolution = nullptr;
Ed Tanous002d39b2022-05-31 08:59:27 -07001602 bool resolved = false;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001603 const std::string* notify = nullptr;
1604
Ed Tanous002d39b2022-05-31 08:59:27 -07001605 for (const auto& interfaceMap : objectPath.second)
1606 {
1607 if (interfaceMap.first ==
1608 "xyz.openbmc_project.Logging.Entry")
Xiaochao Ma75710de2021-01-21 17:56:02 +08001609 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001610 for (const auto& propertyMap : interfaceMap.second)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001611 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001612 if (propertyMap.first == "Id")
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001613 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001614 id = std::get_if<uint32_t>(&propertyMap.second);
1615 }
1616 else if (propertyMap.first == "Timestamp")
1617 {
1618 timestamp =
1619 std::get_if<uint64_t>(&propertyMap.second);
1620 }
1621 else if (propertyMap.first == "UpdateTimestamp")
1622 {
1623 updateTimestamp =
1624 std::get_if<uint64_t>(&propertyMap.second);
1625 }
1626 else if (propertyMap.first == "Severity")
1627 {
1628 severity = std::get_if<std::string>(
1629 &propertyMap.second);
1630 }
Vijay Lobo9c11a172021-10-07 16:53:16 -05001631 else if (propertyMap.first == "Resolution")
1632 {
1633 resolution = std::get_if<std::string>(
1634 &propertyMap.second);
1635 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001636 else if (propertyMap.first == "Message")
1637 {
1638 message = std::get_if<std::string>(
1639 &propertyMap.second);
1640 }
1641 else if (propertyMap.first == "Resolved")
1642 {
1643 const bool* resolveptr =
1644 std::get_if<bool>(&propertyMap.second);
1645 if (resolveptr == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001646 {
1647 messages::internalError(asyncResp->res);
1648 return;
1649 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001650 resolved = *resolveptr;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001651 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001652 else if (propertyMap.first ==
1653 "ServiceProviderNotify")
1654 {
1655 notify = std::get_if<std::string>(
1656 &propertyMap.second);
1657 if (notify == nullptr)
1658 {
1659 messages::internalError(asyncResp->res);
1660 return;
1661 }
1662 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001663 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001664 if (id == nullptr || message == nullptr ||
Ed Tanous002d39b2022-05-31 08:59:27 -07001665 severity == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001666 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001667 messages::internalError(asyncResp->res);
1668 return;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001669 }
1670 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001671 else if (interfaceMap.first ==
1672 "xyz.openbmc_project.Common.FilePath")
1673 {
1674 for (const auto& propertyMap : interfaceMap.second)
1675 {
1676 if (propertyMap.first == "Path")
1677 {
1678 filePath = std::get_if<std::string>(
1679 &propertyMap.second);
1680 }
1681 }
1682 }
1683 }
1684 // Object path without the
1685 // xyz.openbmc_project.Logging.Entry interface, ignore
1686 // and continue.
1687 if (id == nullptr || message == nullptr ||
1688 severity == nullptr || timestamp == nullptr ||
1689 updateTimestamp == nullptr)
1690 {
1691 continue;
1692 }
Ed Tanous3544d2a2023-08-06 18:12:20 -07001693 nlohmann::json& thisEntry = entriesArray.emplace_back();
Vijay Lobo9c11a172021-10-07 16:53:16 -05001694 thisEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001695 thisEntry["@odata.id"] = boost::urls::format(
1696 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1697 std::to_string(*id));
Ed Tanous002d39b2022-05-31 08:59:27 -07001698 thisEntry["Name"] = "System Event Log Entry";
1699 thisEntry["Id"] = std::to_string(*id);
1700 thisEntry["Message"] = *message;
1701 thisEntry["Resolved"] = resolved;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001702 if ((resolution != nullptr) && (!(*resolution).empty()))
1703 {
1704 thisEntry["Resolution"] = *resolution;
1705 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001706 std::optional<bool> notifyAction =
1707 getProviderNotifyAction(*notify);
1708 if (notifyAction)
1709 {
1710 thisEntry["ServiceProviderNotified"] = *notifyAction;
1711 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001712 thisEntry["EntryType"] = "Event";
1713 thisEntry["Severity"] =
1714 translateSeverityDbusToRedfish(*severity);
1715 thisEntry["Created"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001716 redfish::time_utils::getDateTimeUintMs(*timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001717 thisEntry["Modified"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001718 redfish::time_utils::getDateTimeUintMs(*updateTimestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001719 if (filePath != nullptr)
1720 {
1721 thisEntry["AdditionalDataURI"] =
1722 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1723 std::to_string(*id) + "/attachment";
1724 }
1725 }
Ed Tanous3544d2a2023-08-06 18:12:20 -07001726 std::ranges::sort(entriesArray, [](const nlohmann::json& left,
1727 const nlohmann::json& right) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001728 return (left["Id"] <= right["Id"]);
Ed Tanous3544d2a2023-08-06 18:12:20 -07001729 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001730 asyncResp->res.jsonValue["Members@odata.count"] =
1731 entriesArray.size();
Ed Tanous3544d2a2023-08-06 18:12:20 -07001732 asyncResp->res.jsonValue["Members"] = std::move(entriesArray);
George Liu5eb468d2023-06-20 17:03:24 +08001733 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001734 });
1735}
Xiaochao Ma75710de2021-01-21 17:56:02 +08001736
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001737inline void requestRoutesDBusEventLogEntry(App& app)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001738{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001739 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001740 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001741 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07001742 .methods(boost::beast::http::verb::get)(
1743 [&app](const crow::Request& req,
1744 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001745 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001746 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001747 {
1748 return;
1749 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001750 if constexpr (bmcwebEnableMultiHost)
1751 {
1752 // Option currently returns no systems. TBD
1753 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1754 systemName);
1755 return;
1756 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001757 if (systemName != "system")
1758 {
1759 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1760 systemName);
1761 return;
1762 }
1763
Ed Tanous002d39b2022-05-31 08:59:27 -07001764 std::string entryID = param;
1765 dbus::utility::escapePathForDbus(entryID);
1766
1767 // DBus implementation of EventLog/Entries
1768 // Make call to Logging Service to find all log entry objects
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001769 sdbusplus::asio::getAllProperties(
1770 *crow::connections::systemBus, "xyz.openbmc_project.Logging",
1771 "/xyz/openbmc_project/logging/entry/" + entryID, "",
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001772 [asyncResp, entryID](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001773 const dbus::utility::DBusPropertiesMap& resp) {
1774 if (ec.value() == EBADR)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001775 {
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001776 messages::resourceNotFound(asyncResp->res, "EventLogEntry",
1777 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001778 return;
1779 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001780 if (ec)
1781 {
Ed Tanous62598e32023-07-17 17:06:25 -07001782 BMCWEB_LOG_ERROR(
1783 "EventLogEntry (DBus) resp_handler got error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001784 messages::internalError(asyncResp->res);
1785 return;
1786 }
1787 const uint32_t* id = nullptr;
1788 const uint64_t* timestamp = nullptr;
1789 const uint64_t* updateTimestamp = nullptr;
1790 const std::string* severity = nullptr;
1791 const std::string* message = nullptr;
1792 const std::string* filePath = nullptr;
Vijay Lobo9c11a172021-10-07 16:53:16 -05001793 const std::string* resolution = nullptr;
Ed Tanous002d39b2022-05-31 08:59:27 -07001794 bool resolved = false;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001795 const std::string* notify = nullptr;
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001796
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001797 const bool success = sdbusplus::unpackPropertiesNoThrow(
1798 dbus_utils::UnpackErrorPrinter(), resp, "Id", id, "Timestamp",
1799 timestamp, "UpdateTimestamp", updateTimestamp, "Severity",
Vijay Lobo9c11a172021-10-07 16:53:16 -05001800 severity, "Message", message, "Resolved", resolved,
Abhishek Patel9017faf2021-09-14 22:48:55 -05001801 "Resolution", resolution, "Path", filePath,
1802 "ServiceProviderNotify", notify);
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001803
1804 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001805 {
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001806 messages::internalError(asyncResp->res);
1807 return;
Ed Tanous002d39b2022-05-31 08:59:27 -07001808 }
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001809
Ed Tanous002d39b2022-05-31 08:59:27 -07001810 if (id == nullptr || message == nullptr || severity == nullptr ||
Abhishek Patel9017faf2021-09-14 22:48:55 -05001811 timestamp == nullptr || updateTimestamp == nullptr ||
1812 notify == nullptr)
Ed Tanous002d39b2022-05-31 08:59:27 -07001813 {
1814 messages::internalError(asyncResp->res);
1815 return;
1816 }
Abhishek Patel9017faf2021-09-14 22:48:55 -05001817
Ed Tanous002d39b2022-05-31 08:59:27 -07001818 asyncResp->res.jsonValue["@odata.type"] =
Vijay Lobo9c11a172021-10-07 16:53:16 -05001819 "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001820 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
1821 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/{}",
1822 std::to_string(*id));
Ed Tanous002d39b2022-05-31 08:59:27 -07001823 asyncResp->res.jsonValue["Name"] = "System Event Log Entry";
1824 asyncResp->res.jsonValue["Id"] = std::to_string(*id);
1825 asyncResp->res.jsonValue["Message"] = *message;
1826 asyncResp->res.jsonValue["Resolved"] = resolved;
Abhishek Patel9017faf2021-09-14 22:48:55 -05001827 std::optional<bool> notifyAction = getProviderNotifyAction(*notify);
1828 if (notifyAction)
1829 {
1830 asyncResp->res.jsonValue["ServiceProviderNotified"] =
1831 *notifyAction;
1832 }
Vijay Lobo9c11a172021-10-07 16:53:16 -05001833 if ((resolution != nullptr) && (!(*resolution).empty()))
1834 {
1835 asyncResp->res.jsonValue["Resolution"] = *resolution;
1836 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001837 asyncResp->res.jsonValue["EntryType"] = "Event";
1838 asyncResp->res.jsonValue["Severity"] =
1839 translateSeverityDbusToRedfish(*severity);
1840 asyncResp->res.jsonValue["Created"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001841 redfish::time_utils::getDateTimeUintMs(*timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001842 asyncResp->res.jsonValue["Modified"] =
Ed Tanous2b829372022-08-03 14:22:34 -07001843 redfish::time_utils::getDateTimeUintMs(*updateTimestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07001844 if (filePath != nullptr)
1845 {
1846 asyncResp->res.jsonValue["AdditionalDataURI"] =
1847 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1848 std::to_string(*id) + "/attachment";
1849 }
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02001850 });
Ed Tanous45ca1b82022-03-25 13:07:27 -07001851 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001852
1853 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001854 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001855 .privileges(redfish::privileges::patchLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001856 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001857 [&app](const crow::Request& req,
1858 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001859 const std::string& systemName, const std::string& entryId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001860 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001861 {
1862 return;
1863 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001864 if constexpr (bmcwebEnableMultiHost)
1865 {
1866 // Option currently returns no systems. TBD
1867 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1868 systemName);
1869 return;
1870 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001871 if (systemName != "system")
1872 {
1873 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1874 systemName);
1875 return;
1876 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001877 std::optional<bool> resolved;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001878
Ed Tanous002d39b2022-05-31 08:59:27 -07001879 if (!json_util::readJsonPatch(req, asyncResp->res, "Resolved",
1880 resolved))
1881 {
1882 return;
1883 }
Ed Tanous62598e32023-07-17 17:06:25 -07001884 BMCWEB_LOG_DEBUG("Set Resolved");
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001885
George Liu9ae226f2023-06-21 17:56:46 +08001886 sdbusplus::asio::setProperty(
1887 *crow::connections::systemBus, "xyz.openbmc_project.Logging",
1888 "/xyz/openbmc_project/logging/entry/" + entryId,
1889 "xyz.openbmc_project.Logging.Entry", "Resolved", *resolved,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001890 [asyncResp, entryId](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001891 if (ec)
1892 {
Ed Tanous62598e32023-07-17 17:06:25 -07001893 BMCWEB_LOG_DEBUG("DBUS response error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001894 messages::internalError(asyncResp->res);
1895 return;
1896 }
George Liu9ae226f2023-06-21 17:56:46 +08001897 });
Ed Tanous002d39b2022-05-31 08:59:27 -07001898 });
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001899
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001900 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07001901 app, "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001902 .privileges(redfish::privileges::deleteLogEntry)
1903
Ed Tanous002d39b2022-05-31 08:59:27 -07001904 .methods(boost::beast::http::verb::delete_)(
1905 [&app](const crow::Request& req,
1906 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001907 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001908 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001909 {
1910 return;
1911 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001912 if constexpr (bmcwebEnableMultiHost)
1913 {
1914 // Option currently returns no systems. TBD
1915 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1916 systemName);
1917 return;
1918 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001919 if (systemName != "system")
1920 {
1921 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1922 systemName);
1923 return;
1924 }
Ed Tanous62598e32023-07-17 17:06:25 -07001925 BMCWEB_LOG_DEBUG("Do delete single event entries.");
Ed Tanous002d39b2022-05-31 08:59:27 -07001926
1927 std::string entryID = param;
1928
1929 dbus::utility::escapePathForDbus(entryID);
1930
1931 // Process response from Logging service.
1932 auto respHandler =
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001933 [asyncResp, entryID](const boost::system::error_code& ec) {
Ed Tanous62598e32023-07-17 17:06:25 -07001934 BMCWEB_LOG_DEBUG("EventLogEntry (DBus) doDelete callback: Done");
Ed Tanous002d39b2022-05-31 08:59:27 -07001935 if (ec)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001936 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001937 if (ec.value() == EBADR)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001938 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001939 messages::resourceNotFound(asyncResp->res, "LogEntry",
1940 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001941 return;
1942 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001943 // TODO Handle for specific error code
Ed Tanous62598e32023-07-17 17:06:25 -07001944 BMCWEB_LOG_ERROR(
1945 "EventLogEntry (DBus) doDelete respHandler got error {}",
1946 ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07001947 asyncResp->res.result(
1948 boost::beast::http::status::internal_server_error);
1949 return;
1950 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001951
Ed Tanous002d39b2022-05-31 08:59:27 -07001952 asyncResp->res.result(boost::beast::http::status::ok);
1953 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001954
Ed Tanous002d39b2022-05-31 08:59:27 -07001955 // Make call to Logging service to request Delete Log
1956 crow::connections::systemBus->async_method_call(
1957 respHandler, "xyz.openbmc_project.Logging",
1958 "/xyz/openbmc_project/logging/entry/" + entryID,
1959 "xyz.openbmc_project.Object.Delete", "Delete");
Ed Tanous45ca1b82022-03-25 13:07:27 -07001960 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001961}
1962
1963inline void requestRoutesDBusEventLogEntryDownload(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001964{
George Liu0fda0f12021-11-16 10:06:17 +08001965 BMCWEB_ROUTE(
1966 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07001967 "/redfish/v1/Systems/<str>/LogServices/EventLog/Entries/<str>/attachment")
Ed Tanoused398212021-06-09 17:05:54 -07001968 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001969 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001970 [&app](const crow::Request& req,
1971 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001972 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001973 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001974 {
1975 return;
1976 }
Matt Spinler72e21372023-04-19 12:53:33 -05001977 if (!http_helpers::isContentTypeAllowed(
Ed Tanous99351cd2022-08-07 16:42:51 -07001978 req.getHeaderValue("Accept"),
Ed Tanous4a0e1a02022-09-21 15:28:04 -07001979 http_helpers::ContentType::OctetStream, true))
Ed Tanous002d39b2022-05-31 08:59:27 -07001980 {
1981 asyncResp->res.result(boost::beast::http::status::bad_request);
1982 return;
1983 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08001984 if constexpr (bmcwebEnableMultiHost)
1985 {
1986 // Option currently returns no systems. TBD
1987 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1988 systemName);
1989 return;
1990 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001991 if (systemName != "system")
1992 {
1993 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1994 systemName);
1995 return;
1996 }
zhanghch058d1b46d2021-04-01 11:18:24 +08001997
Ed Tanous002d39b2022-05-31 08:59:27 -07001998 std::string entryID = param;
1999 dbus::utility::escapePathForDbus(entryID);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002000
Ed Tanous002d39b2022-05-31 08:59:27 -07002001 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08002002 [asyncResp, entryID](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07002003 const sdbusplus::message::unix_fd& unixfd) {
2004 if (ec.value() == EBADR)
2005 {
2006 messages::resourceNotFound(asyncResp->res, "EventLogAttachment",
2007 entryID);
2008 return;
2009 }
2010 if (ec)
2011 {
Ed Tanous62598e32023-07-17 17:06:25 -07002012 BMCWEB_LOG_DEBUG("DBUS response error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07002013 messages::internalError(asyncResp->res);
2014 return;
2015 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002016
Ed Tanous002d39b2022-05-31 08:59:27 -07002017 int fd = -1;
2018 fd = dup(unixfd);
2019 if (fd == -1)
2020 {
2021 messages::internalError(asyncResp->res);
2022 return;
2023 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002024
Ed Tanous002d39b2022-05-31 08:59:27 -07002025 long long int size = lseek(fd, 0, SEEK_END);
2026 if (size == -1)
2027 {
2028 messages::internalError(asyncResp->res);
2029 return;
2030 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002031
Ed Tanous002d39b2022-05-31 08:59:27 -07002032 // Arbitrary max size of 64kb
2033 constexpr int maxFileSize = 65536;
2034 if (size > maxFileSize)
2035 {
Ed Tanous62598e32023-07-17 17:06:25 -07002036 BMCWEB_LOG_ERROR("File size exceeds maximum allowed size of {}",
2037 maxFileSize);
Ed Tanous002d39b2022-05-31 08:59:27 -07002038 messages::internalError(asyncResp->res);
2039 return;
2040 }
2041 std::vector<char> data(static_cast<size_t>(size));
2042 long long int rc = lseek(fd, 0, SEEK_SET);
2043 if (rc == -1)
2044 {
2045 messages::internalError(asyncResp->res);
2046 return;
2047 }
2048 rc = read(fd, data.data(), data.size());
2049 if ((rc == -1) || (rc != size))
2050 {
2051 messages::internalError(asyncResp->res);
2052 return;
2053 }
2054 close(fd);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002055
Ed Tanous002d39b2022-05-31 08:59:27 -07002056 std::string_view strData(data.data(), data.size());
2057 std::string output = crow::utility::base64encode(strData);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002058
Ed Tanousd9f6c622022-03-17 09:12:17 -07002059 asyncResp->res.addHeader(boost::beast::http::field::content_type,
Ed Tanous002d39b2022-05-31 08:59:27 -07002060 "application/octet-stream");
Ed Tanousd9f6c622022-03-17 09:12:17 -07002061 asyncResp->res.addHeader(
2062 boost::beast::http::field::content_transfer_encoding, "Base64");
Ed Tanous002d39b2022-05-31 08:59:27 -07002063 asyncResp->res.body() = std::move(output);
2064 },
2065 "xyz.openbmc_project.Logging",
2066 "/xyz/openbmc_project/logging/entry/" + entryID,
2067 "xyz.openbmc_project.Logging.Entry", "GetEntry");
2068 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002069}
2070
Spencer Kub7028eb2021-10-26 15:27:35 +08002071constexpr const char* hostLoggerFolderPath = "/var/log/console";
2072
2073inline bool
2074 getHostLoggerFiles(const std::string& hostLoggerFilePath,
2075 std::vector<std::filesystem::path>& hostLoggerFiles)
2076{
2077 std::error_code ec;
2078 std::filesystem::directory_iterator logPath(hostLoggerFilePath, ec);
2079 if (ec)
2080 {
Carson Labradobf2dded2023-08-10 00:37:06 +00002081 BMCWEB_LOG_WARNING("{}", ec.message());
Spencer Kub7028eb2021-10-26 15:27:35 +08002082 return false;
2083 }
2084 for (const std::filesystem::directory_entry& it : logPath)
2085 {
2086 std::string filename = it.path().filename();
2087 // Prefix of each log files is "log". Find the file and save the
2088 // path
Ed Tanous11ba3972022-07-11 09:50:41 -07002089 if (filename.starts_with("log"))
Spencer Kub7028eb2021-10-26 15:27:35 +08002090 {
2091 hostLoggerFiles.emplace_back(it.path());
2092 }
2093 }
2094 // As the log files rotate, they are appended with a ".#" that is higher for
2095 // the older logs. Since we start from oldest logs, sort the name in
2096 // descending order.
2097 std::sort(hostLoggerFiles.rbegin(), hostLoggerFiles.rend(),
2098 AlphanumLess<std::string>());
2099
2100 return true;
2101}
2102
Ed Tanous02cad962022-06-30 16:50:15 -07002103inline bool getHostLoggerEntries(
2104 const std::vector<std::filesystem::path>& hostLoggerFiles, uint64_t skip,
2105 uint64_t top, std::vector<std::string>& logEntries, size_t& logCount)
Spencer Kub7028eb2021-10-26 15:27:35 +08002106{
2107 GzFileReader logFile;
2108
2109 // Go though all log files and expose host logs.
2110 for (const std::filesystem::path& it : hostLoggerFiles)
2111 {
2112 if (!logFile.gzGetLines(it.string(), skip, top, logEntries, logCount))
2113 {
Ed Tanous62598e32023-07-17 17:06:25 -07002114 BMCWEB_LOG_ERROR("fail to expose host logs");
Spencer Kub7028eb2021-10-26 15:27:35 +08002115 return false;
2116 }
2117 }
2118 // Get lastMessage from constructor by getter
2119 std::string lastMessage = logFile.getLastMessage();
2120 if (!lastMessage.empty())
2121 {
2122 logCount++;
2123 if (logCount > skip && logCount <= (skip + top))
2124 {
2125 logEntries.push_back(lastMessage);
2126 }
2127 }
2128 return true;
2129}
2130
2131inline void fillHostLoggerEntryJson(const std::string& logEntryID,
2132 const std::string& msg,
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002133 nlohmann::json::object_t& logEntryJson)
Spencer Kub7028eb2021-10-26 15:27:35 +08002134{
2135 // Fill in the log entry with the gathered data.
Vijay Lobo9c11a172021-10-07 16:53:16 -05002136 logEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07002137 logEntryJson["@odata.id"] = boost::urls::format(
2138 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries/{}",
2139 logEntryID);
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002140 logEntryJson["Name"] = "Host Logger Entry";
2141 logEntryJson["Id"] = logEntryID;
2142 logEntryJson["Message"] = msg;
2143 logEntryJson["EntryType"] = "Oem";
2144 logEntryJson["Severity"] = "OK";
2145 logEntryJson["OemRecordFormat"] = "Host Logger Entry";
Spencer Kub7028eb2021-10-26 15:27:35 +08002146}
2147
2148inline void requestRoutesSystemHostLogger(App& app)
2149{
Ed Tanous22d268c2022-05-19 09:39:07 -07002150 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/HostLogger/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002151 .privileges(redfish::privileges::getLogService)
Ed Tanous14766872022-03-15 10:44:42 -07002152 .methods(boost::beast::http::verb::get)(
2153 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07002154 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2155 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002156 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002157 {
2158 return;
2159 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002160 if constexpr (bmcwebEnableMultiHost)
2161 {
2162 // Option currently returns no systems. TBD
2163 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2164 systemName);
2165 return;
2166 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002167 if (systemName != "system")
2168 {
2169 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2170 systemName);
2171 return;
2172 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002173 asyncResp->res.jsonValue["@odata.id"] =
2174 "/redfish/v1/Systems/system/LogServices/HostLogger";
2175 asyncResp->res.jsonValue["@odata.type"] =
2176 "#LogService.v1_1_0.LogService";
2177 asyncResp->res.jsonValue["Name"] = "Host Logger Service";
2178 asyncResp->res.jsonValue["Description"] = "Host Logger Service";
2179 asyncResp->res.jsonValue["Id"] = "HostLogger";
2180 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2181 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
2182 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002183}
2184
2185inline void requestRoutesSystemHostLoggerCollection(App& app)
2186{
2187 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07002188 "/redfish/v1/Systems/<str>/LogServices/HostLogger/Entries/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002189 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07002190 .methods(boost::beast::http::verb::get)(
2191 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07002192 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2193 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07002194 query_param::QueryCapabilities capabilities = {
2195 .canDelegateTop = true,
2196 .canDelegateSkip = true,
2197 };
2198 query_param::Query delegatedQuery;
2199 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00002200 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07002201 {
2202 return;
2203 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002204 if constexpr (bmcwebEnableMultiHost)
2205 {
2206 // Option currently returns no systems. TBD
2207 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2208 systemName);
2209 return;
2210 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002211 if (systemName != "system")
2212 {
2213 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2214 systemName);
2215 return;
2216 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002217 asyncResp->res.jsonValue["@odata.id"] =
2218 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
2219 asyncResp->res.jsonValue["@odata.type"] =
2220 "#LogEntryCollection.LogEntryCollection";
2221 asyncResp->res.jsonValue["Name"] = "HostLogger Entries";
2222 asyncResp->res.jsonValue["Description"] =
2223 "Collection of HostLogger Entries";
2224 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
2225 logEntryArray = nlohmann::json::array();
2226 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Spencer Kub7028eb2021-10-26 15:27:35 +08002227
Ed Tanous002d39b2022-05-31 08:59:27 -07002228 std::vector<std::filesystem::path> hostLoggerFiles;
2229 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
2230 {
Carson Labradobf2dded2023-08-10 00:37:06 +00002231 BMCWEB_LOG_DEBUG("Failed to get host log file path");
Ed Tanous002d39b2022-05-31 08:59:27 -07002232 return;
2233 }
Ed Tanous3648c8b2022-07-25 13:39:59 -07002234 // If we weren't provided top and skip limits, use the defaults.
2235 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08002236 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous002d39b2022-05-31 08:59:27 -07002237 size_t logCount = 0;
2238 // This vector only store the entries we want to expose that
2239 // control by skip and top.
2240 std::vector<std::string> logEntries;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002241 if (!getHostLoggerEntries(hostLoggerFiles, skip, top, logEntries,
2242 logCount))
Ed Tanous002d39b2022-05-31 08:59:27 -07002243 {
2244 messages::internalError(asyncResp->res);
2245 return;
2246 }
2247 // If vector is empty, that means skip value larger than total
2248 // log count
2249 if (logEntries.empty())
2250 {
2251 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
2252 return;
2253 }
2254 if (!logEntries.empty())
2255 {
2256 for (size_t i = 0; i < logEntries.size(); i++)
George Liu0fda0f12021-11-16 10:06:17 +08002257 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002258 nlohmann::json::object_t hostLogEntry;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002259 fillHostLoggerEntryJson(std::to_string(skip + i), logEntries[i],
2260 hostLogEntry);
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002261 logEntryArray.emplace_back(std::move(hostLogEntry));
George Liu0fda0f12021-11-16 10:06:17 +08002262 }
2263
Ed Tanous002d39b2022-05-31 08:59:27 -07002264 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002265 if (skip + top < logCount)
George Liu0fda0f12021-11-16 10:06:17 +08002266 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002267 asyncResp->res.jsonValue["Members@odata.nextLink"] =
2268 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07002269 std::to_string(skip + top);
George Liu0fda0f12021-11-16 10:06:17 +08002270 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002271 }
George Liu0fda0f12021-11-16 10:06:17 +08002272 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002273}
2274
2275inline void requestRoutesSystemHostLoggerLogEntry(App& app)
2276{
2277 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07002278 app, "/redfish/v1/Systems/<str>/LogServices/HostLogger/Entries/<str>/")
Spencer Kub7028eb2021-10-26 15:27:35 +08002279 .privileges(redfish::privileges::getLogEntry)
2280 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002281 [&app](const crow::Request& req,
2282 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07002283 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002284 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002285 {
2286 return;
2287 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002288 if constexpr (bmcwebEnableMultiHost)
2289 {
2290 // Option currently returns no systems. TBD
2291 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2292 systemName);
2293 return;
2294 }
Ed Tanous22d268c2022-05-19 09:39:07 -07002295 if (systemName != "system")
2296 {
2297 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2298 systemName);
2299 return;
2300 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002301 const std::string& targetID = param;
Spencer Kub7028eb2021-10-26 15:27:35 +08002302
Ed Tanous002d39b2022-05-31 08:59:27 -07002303 uint64_t idInt = 0;
Ed Tanousca45aa32022-01-07 09:28:45 -08002304
Patrick Williams84396af2023-05-11 11:47:45 -05002305 auto [ptr, ec] = std::from_chars(&*targetID.begin(), &*targetID.end(),
2306 idInt);
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002307 if (ec == std::errc::invalid_argument ||
2308 ec == std::errc::result_out_of_range)
Ed Tanous002d39b2022-05-31 08:59:27 -07002309 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002310 messages::resourceNotFound(asyncResp->res, "LogEntry", param);
Ed Tanous002d39b2022-05-31 08:59:27 -07002311 return;
2312 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002313
Ed Tanous002d39b2022-05-31 08:59:27 -07002314 std::vector<std::filesystem::path> hostLoggerFiles;
2315 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
2316 {
Carson Labradobf2dded2023-08-10 00:37:06 +00002317 BMCWEB_LOG_DEBUG("Failed to get host log file path");
Ed Tanous002d39b2022-05-31 08:59:27 -07002318 return;
2319 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002320
Ed Tanous002d39b2022-05-31 08:59:27 -07002321 size_t logCount = 0;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002322 size_t top = 1;
Ed Tanous002d39b2022-05-31 08:59:27 -07002323 std::vector<std::string> logEntries;
2324 // We can get specific entry by skip and top. For example, if we
2325 // want to get nth entry, we can set skip = n-1 and top = 1 to
2326 // get that entry
2327 if (!getHostLoggerEntries(hostLoggerFiles, idInt, top, logEntries,
2328 logCount))
2329 {
2330 messages::internalError(asyncResp->res);
2331 return;
2332 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002333
Ed Tanous002d39b2022-05-31 08:59:27 -07002334 if (!logEntries.empty())
2335 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07002336 nlohmann::json::object_t hostLogEntry;
2337 fillHostLoggerEntryJson(targetID, logEntries[0], hostLogEntry);
2338 asyncResp->res.jsonValue.update(hostLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002339 return;
2340 }
Spencer Kub7028eb2021-10-26 15:27:35 +08002341
Ed Tanous002d39b2022-05-31 08:59:27 -07002342 // Requested ID was not found
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002343 messages::resourceNotFound(asyncResp->res, "LogEntry", param);
Ed Tanous002d39b2022-05-31 08:59:27 -07002344 });
Spencer Kub7028eb2021-10-26 15:27:35 +08002345}
2346
Claire Weinandd72e872022-08-15 14:20:06 -07002347inline void handleBMCLogServicesCollectionGet(
Claire Weinanfdd26902022-03-01 14:18:25 -08002348 crow::App& app, const crow::Request& req,
2349 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2350{
2351 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2352 {
2353 return;
2354 }
2355 // Collections don't include the static data added by SubRoute
2356 // because it has a duplicate entry for members
2357 asyncResp->res.jsonValue["@odata.type"] =
2358 "#LogServiceCollection.LogServiceCollection";
2359 asyncResp->res.jsonValue["@odata.id"] =
2360 "/redfish/v1/Managers/bmc/LogServices";
2361 asyncResp->res.jsonValue["Name"] = "Open BMC Log Services Collection";
2362 asyncResp->res.jsonValue["Description"] =
2363 "Collection of LogServices for this Manager";
2364 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
2365 logServiceArray = nlohmann::json::array();
2366
2367#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
Ed Tanous613dabe2022-07-09 11:17:36 -07002368 nlohmann::json::object_t journal;
2369 journal["@odata.id"] = "/redfish/v1/Managers/bmc/LogServices/Journal";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002370 logServiceArray.emplace_back(std::move(journal));
Claire Weinanfdd26902022-03-01 14:18:25 -08002371#endif
2372
2373 asyncResp->res.jsonValue["Members@odata.count"] = logServiceArray.size();
2374
2375#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
George Liu15912152023-01-11 10:18:18 +08002376 constexpr std::array<std::string_view, 1> interfaces = {
George Liu7a1dbc42022-12-07 16:03:22 +08002377 "xyz.openbmc_project.Collection.DeleteAll"};
2378 dbus::utility::getSubTreePaths(
2379 "/xyz/openbmc_project/dump", 0, interfaces,
Claire Weinanfdd26902022-03-01 14:18:25 -08002380 [asyncResp](
George Liu7a1dbc42022-12-07 16:03:22 +08002381 const boost::system::error_code& ec,
Claire Weinanfdd26902022-03-01 14:18:25 -08002382 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
2383 if (ec)
2384 {
Ed Tanous62598e32023-07-17 17:06:25 -07002385 BMCWEB_LOG_ERROR(
2386 "handleBMCLogServicesCollectionGet respHandler got error {}",
2387 ec);
Claire Weinanfdd26902022-03-01 14:18:25 -08002388 // Assume that getting an error simply means there are no dump
2389 // LogServices. Return without adding any error response.
2390 return;
2391 }
2392
2393 nlohmann::json& logServiceArrayLocal =
2394 asyncResp->res.jsonValue["Members"];
2395
2396 for (const std::string& path : subTreePaths)
2397 {
2398 if (path == "/xyz/openbmc_project/dump/bmc")
2399 {
Ed Tanous613dabe2022-07-09 11:17:36 -07002400 nlohmann::json::object_t member;
2401 member["@odata.id"] =
2402 "/redfish/v1/Managers/bmc/LogServices/Dump";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002403 logServiceArrayLocal.emplace_back(std::move(member));
Claire Weinanfdd26902022-03-01 14:18:25 -08002404 }
2405 else if (path == "/xyz/openbmc_project/dump/faultlog")
2406 {
Ed Tanous613dabe2022-07-09 11:17:36 -07002407 nlohmann::json::object_t member;
2408 member["@odata.id"] =
2409 "/redfish/v1/Managers/bmc/LogServices/FaultLog";
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002410 logServiceArrayLocal.emplace_back(std::move(member));
Claire Weinanfdd26902022-03-01 14:18:25 -08002411 }
2412 }
2413
2414 asyncResp->res.jsonValue["Members@odata.count"] =
2415 logServiceArrayLocal.size();
George Liu7a1dbc42022-12-07 16:03:22 +08002416 });
Claire Weinanfdd26902022-03-01 14:18:25 -08002417#endif
2418}
2419
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002420inline void requestRoutesBMCLogServiceCollection(App& app)
2421{
2422 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/")
Gunnar Millsad89dcf2021-07-30 14:40:11 -05002423 .privileges(redfish::privileges::getLogServiceCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002424 .methods(boost::beast::http::verb::get)(
Claire Weinandd72e872022-08-15 14:20:06 -07002425 std::bind_front(handleBMCLogServicesCollectionGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002426}
Ed Tanous1da66f72018-07-27 16:13:37 -07002427
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002428inline void requestRoutesBMCJournalLogService(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07002429{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002430 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/")
Ed Tanoused398212021-06-09 17:05:54 -07002431 .privileges(redfish::privileges::getLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002432 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002433 [&app](const crow::Request& req,
2434 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002435 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002436 {
2437 return;
2438 }
2439 asyncResp->res.jsonValue["@odata.type"] =
2440 "#LogService.v1_1_0.LogService";
2441 asyncResp->res.jsonValue["@odata.id"] =
2442 "/redfish/v1/Managers/bmc/LogServices/Journal";
2443 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Log Service";
2444 asyncResp->res.jsonValue["Description"] = "BMC Journal Log Service";
Ed Tanoused34a4a2023-02-08 15:43:27 -08002445 asyncResp->res.jsonValue["Id"] = "Journal";
Ed Tanous002d39b2022-05-31 08:59:27 -07002446 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05302447
Ed Tanous002d39b2022-05-31 08:59:27 -07002448 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07002449 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07002450 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2451 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2452 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302453
Ed Tanous002d39b2022-05-31 08:59:27 -07002454 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2455 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2456 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002457}
Jason M. Billse1f26342018-07-18 12:12:00 -07002458
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002459static int
2460 fillBMCJournalLogEntryJson(const std::string& bmcJournalLogEntryID,
2461 sd_journal* journal,
2462 nlohmann::json::object_t& bmcJournalLogEntryJson)
Jason M. Billse1f26342018-07-18 12:12:00 -07002463{
2464 // Get the Log Entry contents
2465 int ret = 0;
Jason M. Billse1f26342018-07-18 12:12:00 -07002466
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002467 std::string message;
2468 std::string_view syslogID;
2469 ret = getJournalMetadata(journal, "SYSLOG_IDENTIFIER", syslogID);
2470 if (ret < 0)
2471 {
Carson Labradobf2dded2023-08-10 00:37:06 +00002472 BMCWEB_LOG_DEBUG("Failed to read SYSLOG_IDENTIFIER field: {}",
Ed Tanous62598e32023-07-17 17:06:25 -07002473 strerror(-ret));
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002474 }
2475 if (!syslogID.empty())
2476 {
2477 message += std::string(syslogID) + ": ";
2478 }
2479
Ed Tanous39e77502019-03-04 17:35:53 -08002480 std::string_view msg;
Jason M. Bills16428a12018-11-02 12:42:29 -07002481 ret = getJournalMetadata(journal, "MESSAGE", msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002482 if (ret < 0)
2483 {
Ed Tanous62598e32023-07-17 17:06:25 -07002484 BMCWEB_LOG_ERROR("Failed to read MESSAGE field: {}", strerror(-ret));
Jason M. Billse1f26342018-07-18 12:12:00 -07002485 return 1;
2486 }
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002487 message += std::string(msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002488
2489 // Get the severity from the PRIORITY field
Ed Tanous271584a2019-07-09 16:24:22 -07002490 long int severity = 8; // Default to an invalid priority
Jason M. Bills16428a12018-11-02 12:42:29 -07002491 ret = getJournalMetadata(journal, "PRIORITY", 10, severity);
Jason M. Billse1f26342018-07-18 12:12:00 -07002492 if (ret < 0)
2493 {
Carson Labradobf2dded2023-08-10 00:37:06 +00002494 BMCWEB_LOG_DEBUG("Failed to read PRIORITY field: {}", strerror(-ret));
Jason M. Billse1f26342018-07-18 12:12:00 -07002495 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002496
2497 // Get the Created time from the timestamp
Jason M. Bills16428a12018-11-02 12:42:29 -07002498 std::string entryTimeStr;
2499 if (!getEntryTimestamp(journal, entryTimeStr))
Jason M. Billse1f26342018-07-18 12:12:00 -07002500 {
Jason M. Bills16428a12018-11-02 12:42:29 -07002501 return 1;
Jason M. Billse1f26342018-07-18 12:12:00 -07002502 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002503
2504 // Fill in the log entry with the gathered data
Vijay Lobo9c11a172021-10-07 16:53:16 -05002505 bmcJournalLogEntryJson["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07002506 bmcJournalLogEntryJson["@odata.id"] = boost::urls::format(
2507 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/{}",
Willy Tueddfc432022-09-26 16:46:38 +00002508 bmcJournalLogEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07002509 bmcJournalLogEntryJson["Name"] = "BMC Journal Entry";
2510 bmcJournalLogEntryJson["Id"] = bmcJournalLogEntryID;
2511 bmcJournalLogEntryJson["Message"] = std::move(message);
2512 bmcJournalLogEntryJson["EntryType"] = "Oem";
2513 bmcJournalLogEntryJson["Severity"] = severity <= 2 ? "Critical"
2514 : severity <= 4 ? "Warning"
2515 : "OK";
2516 bmcJournalLogEntryJson["OemRecordFormat"] = "BMC Journal Entry";
2517 bmcJournalLogEntryJson["Created"] = std::move(entryTimeStr);
Jason M. Billse1f26342018-07-18 12:12:00 -07002518 return 0;
2519}
2520
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002521inline void requestRoutesBMCJournalLogEntryCollection(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002522{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002523 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002524 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07002525 .methods(boost::beast::http::verb::get)(
2526 [&app](const crow::Request& req,
2527 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
2528 query_param::QueryCapabilities capabilities = {
2529 .canDelegateTop = true,
2530 .canDelegateSkip = true,
2531 };
2532 query_param::Query delegatedQuery;
2533 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00002534 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07002535 {
2536 return;
2537 }
Ed Tanous3648c8b2022-07-25 13:39:59 -07002538
2539 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08002540 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07002541
Ed Tanous002d39b2022-05-31 08:59:27 -07002542 // Collections don't include the static data added by SubRoute
2543 // because it has a duplicate entry for members
2544 asyncResp->res.jsonValue["@odata.type"] =
2545 "#LogEntryCollection.LogEntryCollection";
2546 asyncResp->res.jsonValue["@odata.id"] =
2547 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2548 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Entries";
2549 asyncResp->res.jsonValue["Description"] =
2550 "Collection of BMC Journal Entries";
2551 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
2552 logEntryArray = nlohmann::json::array();
Jason M. Billse1f26342018-07-18 12:12:00 -07002553
Ed Tanous002d39b2022-05-31 08:59:27 -07002554 // Go through the journal and use the timestamp to create a
2555 // unique ID for each entry
2556 sd_journal* journalTmp = nullptr;
2557 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2558 if (ret < 0)
2559 {
Ed Tanous62598e32023-07-17 17:06:25 -07002560 BMCWEB_LOG_ERROR("failed to open journal: {}", strerror(-ret));
Ed Tanous002d39b2022-05-31 08:59:27 -07002561 messages::internalError(asyncResp->res);
2562 return;
2563 }
2564 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2565 journalTmp, sd_journal_close);
2566 journalTmp = nullptr;
2567 uint64_t entryCount = 0;
2568 // Reset the unique ID on the first entry
2569 bool firstEntry = true;
2570 SD_JOURNAL_FOREACH(journal.get())
2571 {
2572 entryCount++;
2573 // Handle paging using skip (number of entries to skip from
2574 // the start) and top (number of entries to display)
Ed Tanous3648c8b2022-07-25 13:39:59 -07002575 if (entryCount <= skip || entryCount > skip + top)
George Liu0fda0f12021-11-16 10:06:17 +08002576 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002577 continue;
2578 }
2579
2580 std::string idStr;
2581 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2582 {
2583 continue;
2584 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002585 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002586
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002587 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002588 if (fillBMCJournalLogEntryJson(idStr, journal.get(),
2589 bmcJournalLogEntry) != 0)
2590 {
George Liu0fda0f12021-11-16 10:06:17 +08002591 messages::internalError(asyncResp->res);
2592 return;
2593 }
Patrick Williamsb2ba3072023-05-12 10:27:39 -05002594 logEntryArray.emplace_back(std::move(bmcJournalLogEntry));
Ed Tanous002d39b2022-05-31 08:59:27 -07002595 }
2596 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
Ed Tanous3648c8b2022-07-25 13:39:59 -07002597 if (skip + top < entryCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07002598 {
2599 asyncResp->res.jsonValue["Members@odata.nextLink"] =
2600 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries?$skip=" +
Ed Tanous3648c8b2022-07-25 13:39:59 -07002601 std::to_string(skip + top);
Ed Tanous002d39b2022-05-31 08:59:27 -07002602 }
George Liu0fda0f12021-11-16 10:06:17 +08002603 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002604}
Jason M. Billse1f26342018-07-18 12:12:00 -07002605
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002606inline void requestRoutesBMCJournalLogEntry(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002607{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002608 BMCWEB_ROUTE(app,
2609 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002610 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002611 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002612 [&app](const crow::Request& req,
2613 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2614 const std::string& entryID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002615 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002616 {
2617 return;
2618 }
2619 // Convert the unique ID back to a timestamp to find the entry
2620 uint64_t ts = 0;
2621 uint64_t index = 0;
2622 if (!getTimestampFromID(asyncResp, entryID, ts, index))
2623 {
2624 return;
2625 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002626
Ed Tanous002d39b2022-05-31 08:59:27 -07002627 sd_journal* journalTmp = nullptr;
2628 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2629 if (ret < 0)
2630 {
Ed Tanous62598e32023-07-17 17:06:25 -07002631 BMCWEB_LOG_ERROR("failed to open journal: {}", strerror(-ret));
Ed Tanous002d39b2022-05-31 08:59:27 -07002632 messages::internalError(asyncResp->res);
2633 return;
2634 }
2635 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2636 journalTmp, sd_journal_close);
2637 journalTmp = nullptr;
2638 // Go to the timestamp in the log and move to the entry at the
2639 // index tracking the unique ID
2640 std::string idStr;
2641 bool firstEntry = true;
2642 ret = sd_journal_seek_realtime_usec(journal.get(), ts);
2643 if (ret < 0)
2644 {
Ed Tanous62598e32023-07-17 17:06:25 -07002645 BMCWEB_LOG_ERROR("failed to seek to an entry in journal{}",
2646 strerror(-ret));
Ed Tanous002d39b2022-05-31 08:59:27 -07002647 messages::internalError(asyncResp->res);
2648 return;
2649 }
2650 for (uint64_t i = 0; i <= index; i++)
2651 {
2652 sd_journal_next(journal.get());
2653 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2654 {
2655 messages::internalError(asyncResp->res);
2656 return;
2657 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002658 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002659 }
2660 // Confirm that the entry ID matches what was requested
2661 if (idStr != entryID)
2662 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08002663 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
Ed Tanous002d39b2022-05-31 08:59:27 -07002664 return;
2665 }
zhanghch058d1b46d2021-04-01 11:18:24 +08002666
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002667 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002668 if (fillBMCJournalLogEntryJson(entryID, journal.get(),
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002669 bmcJournalLogEntry) != 0)
Ed Tanous002d39b2022-05-31 08:59:27 -07002670 {
2671 messages::internalError(asyncResp->res);
2672 return;
2673 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07002674 asyncResp->res.jsonValue.update(bmcJournalLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002675 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002676}
2677
Claire Weinanfdd26902022-03-01 14:18:25 -08002678inline void
2679 getDumpServiceInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2680 const std::string& dumpType)
2681{
2682 std::string dumpPath;
2683 std::string overWritePolicy;
2684 bool collectDiagnosticDataSupported = false;
2685
2686 if (dumpType == "BMC")
2687 {
2688 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump";
2689 overWritePolicy = "WrapsWhenFull";
2690 collectDiagnosticDataSupported = true;
2691 }
2692 else if (dumpType == "FaultLog")
2693 {
2694 dumpPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog";
2695 overWritePolicy = "Unknown";
2696 collectDiagnosticDataSupported = false;
2697 }
2698 else if (dumpType == "System")
2699 {
2700 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump";
2701 overWritePolicy = "WrapsWhenFull";
2702 collectDiagnosticDataSupported = true;
2703 }
2704 else
2705 {
Ed Tanous62598e32023-07-17 17:06:25 -07002706 BMCWEB_LOG_ERROR("getDumpServiceInfo() invalid dump type: {}",
2707 dumpType);
Claire Weinanfdd26902022-03-01 14:18:25 -08002708 messages::internalError(asyncResp->res);
2709 return;
2710 }
2711
2712 asyncResp->res.jsonValue["@odata.id"] = dumpPath;
2713 asyncResp->res.jsonValue["@odata.type"] = "#LogService.v1_2_0.LogService";
2714 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2715 asyncResp->res.jsonValue["Description"] = dumpType + " Dump LogService";
2716 asyncResp->res.jsonValue["Id"] = std::filesystem::path(dumpPath).filename();
2717 asyncResp->res.jsonValue["OverWritePolicy"] = std::move(overWritePolicy);
2718
2719 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07002720 redfish::time_utils::getDateTimeOffsetNow();
Claire Weinanfdd26902022-03-01 14:18:25 -08002721 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2722 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2723 redfishDateTimeOffset.second;
2724
2725 asyncResp->res.jsonValue["Entries"]["@odata.id"] = dumpPath + "/Entries";
Claire Weinanfdd26902022-03-01 14:18:25 -08002726
2727 if (collectDiagnosticDataSupported)
2728 {
2729 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
2730 ["target"] =
2731 dumpPath + "/Actions/LogService.CollectDiagnosticData";
2732 }
Claire Weinan0d946212022-07-13 19:40:19 -07002733
2734 constexpr std::array<std::string_view, 1> interfaces = {deleteAllInterface};
2735 dbus::utility::getSubTreePaths(
2736 "/xyz/openbmc_project/dump", 0, interfaces,
2737 [asyncResp, dumpType, dumpPath](
2738 const boost::system::error_code& ec,
2739 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
2740 if (ec)
2741 {
Ed Tanous62598e32023-07-17 17:06:25 -07002742 BMCWEB_LOG_ERROR("getDumpServiceInfo respHandler got error {}", ec);
Claire Weinan0d946212022-07-13 19:40:19 -07002743 // Assume that getting an error simply means there are no dump
2744 // LogServices. Return without adding any error response.
2745 return;
2746 }
2747
2748 const std::string dbusDumpPath =
2749 "/xyz/openbmc_project/dump/" +
2750 boost::algorithm::to_lower_copy(dumpType);
2751
2752 for (const std::string& path : subTreePaths)
2753 {
2754 if (path == dbusDumpPath)
2755 {
2756 asyncResp->res
2757 .jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
2758 dumpPath + "/Actions/LogService.ClearLog";
2759 break;
2760 }
2761 }
2762 });
Claire Weinanfdd26902022-03-01 14:18:25 -08002763}
2764
2765inline void handleLogServicesDumpServiceGet(
2766 crow::App& app, const std::string& dumpType, const crow::Request& req,
2767 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2768{
2769 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2770 {
2771 return;
2772 }
2773 getDumpServiceInfo(asyncResp, dumpType);
2774}
2775
Ed Tanous22d268c2022-05-19 09:39:07 -07002776inline void handleLogServicesDumpServiceComputerSystemGet(
2777 crow::App& app, const crow::Request& req,
2778 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2779 const std::string& chassisId)
2780{
2781 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2782 {
2783 return;
2784 }
2785 if (chassisId != "system")
2786 {
2787 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2788 return;
2789 }
2790 getDumpServiceInfo(asyncResp, "System");
2791}
2792
Claire Weinanfdd26902022-03-01 14:18:25 -08002793inline void handleLogServicesDumpEntriesCollectionGet(
2794 crow::App& app, const std::string& dumpType, const crow::Request& req,
2795 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2796{
2797 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2798 {
2799 return;
2800 }
2801 getDumpEntryCollection(asyncResp, dumpType);
2802}
2803
Ed Tanous22d268c2022-05-19 09:39:07 -07002804inline void handleLogServicesDumpEntriesCollectionComputerSystemGet(
2805 crow::App& app, const crow::Request& req,
2806 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2807 const std::string& chassisId)
2808{
2809 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2810 {
2811 return;
2812 }
2813 if (chassisId != "system")
2814 {
2815 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2816 return;
2817 }
2818 getDumpEntryCollection(asyncResp, "System");
2819}
2820
Claire Weinanfdd26902022-03-01 14:18:25 -08002821inline void handleLogServicesDumpEntryGet(
2822 crow::App& app, const std::string& dumpType, const crow::Request& req,
2823 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2824 const std::string& dumpId)
2825{
2826 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2827 {
2828 return;
2829 }
2830 getDumpEntryById(asyncResp, dumpId, dumpType);
2831}
Ed Tanous22d268c2022-05-19 09:39:07 -07002832inline void handleLogServicesDumpEntryComputerSystemGet(
2833 crow::App& app, const crow::Request& req,
2834 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2835 const std::string& chassisId, const std::string& dumpId)
2836{
2837 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2838 {
2839 return;
2840 }
2841 if (chassisId != "system")
2842 {
2843 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2844 return;
2845 }
2846 getDumpEntryById(asyncResp, dumpId, "System");
2847}
Claire Weinanfdd26902022-03-01 14:18:25 -08002848
2849inline void handleLogServicesDumpEntryDelete(
2850 crow::App& app, const std::string& dumpType, const crow::Request& req,
2851 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2852 const std::string& dumpId)
2853{
2854 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2855 {
2856 return;
2857 }
2858 deleteDumpEntry(asyncResp, dumpId, dumpType);
2859}
2860
Ed Tanous22d268c2022-05-19 09:39:07 -07002861inline void handleLogServicesDumpEntryComputerSystemDelete(
2862 crow::App& app, const crow::Request& req,
2863 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2864 const std::string& chassisId, const std::string& dumpId)
2865{
2866 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2867 {
2868 return;
2869 }
2870 if (chassisId != "system")
2871 {
2872 messages::resourceNotFound(asyncResp->res, "ComputerSystem", chassisId);
2873 return;
2874 }
2875 deleteDumpEntry(asyncResp, dumpId, "System");
2876}
2877
Claire Weinanfdd26902022-03-01 14:18:25 -08002878inline void handleLogServicesDumpCollectDiagnosticDataPost(
2879 crow::App& app, const std::string& dumpType, const crow::Request& req,
2880 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2881{
2882 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2883 {
2884 return;
2885 }
2886 createDump(asyncResp, req, dumpType);
2887}
2888
Ed Tanous22d268c2022-05-19 09:39:07 -07002889inline void handleLogServicesDumpCollectDiagnosticDataComputerSystemPost(
2890 crow::App& app, const crow::Request& req,
2891 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002892 const std::string& systemName)
Ed Tanous22d268c2022-05-19 09:39:07 -07002893{
2894 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2895 {
2896 return;
2897 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002898
2899 if constexpr (bmcwebEnableMultiHost)
Ed Tanous22d268c2022-05-19 09:39:07 -07002900 {
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002901 // Option currently returns no systems. TBD
2902 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2903 systemName);
2904 return;
2905 }
2906 if (systemName != "system")
2907 {
2908 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2909 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07002910 return;
2911 }
2912 createDump(asyncResp, req, "System");
2913}
2914
Claire Weinanfdd26902022-03-01 14:18:25 -08002915inline void handleLogServicesDumpClearLogPost(
2916 crow::App& app, const std::string& dumpType, const crow::Request& req,
2917 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2918{
2919 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2920 {
2921 return;
2922 }
2923 clearDump(asyncResp, dumpType);
2924}
2925
Ed Tanous22d268c2022-05-19 09:39:07 -07002926inline void handleLogServicesDumpClearLogComputerSystemPost(
2927 crow::App& app, const crow::Request& req,
2928 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002929 const std::string& systemName)
Ed Tanous22d268c2022-05-19 09:39:07 -07002930{
2931 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2932 {
2933 return;
2934 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002935 if constexpr (bmcwebEnableMultiHost)
Ed Tanous22d268c2022-05-19 09:39:07 -07002936 {
Ed Tanous7f3e84a2022-12-28 16:22:54 -08002937 // Option currently returns no systems. TBD
2938 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2939 systemName);
2940 return;
2941 }
2942 if (systemName != "system")
2943 {
2944 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
2945 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07002946 return;
2947 }
2948 clearDump(asyncResp, "System");
2949}
2950
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002951inline void requestRoutesBMCDumpService(App& app)
2952{
2953 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07002954 .privileges(redfish::privileges::getLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002955 .methods(boost::beast::http::verb::get)(std::bind_front(
2956 handleLogServicesDumpServiceGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002957}
2958
2959inline void requestRoutesBMCDumpEntryCollection(App& app)
2960{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002961 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002962 .privileges(redfish::privileges::getLogEntryCollection)
Claire Weinanfdd26902022-03-01 14:18:25 -08002963 .methods(boost::beast::http::verb::get)(std::bind_front(
2964 handleLogServicesDumpEntriesCollectionGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002965}
2966
2967inline void requestRoutesBMCDumpEntry(App& app)
2968{
2969 BMCWEB_ROUTE(app,
2970 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002971 .privileges(redfish::privileges::getLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002972 .methods(boost::beast::http::verb::get)(std::bind_front(
2973 handleLogServicesDumpEntryGet, std::ref(app), "BMC"));
2974
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002975 BMCWEB_ROUTE(app,
2976 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002977 .privileges(redfish::privileges::deleteLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002978 .methods(boost::beast::http::verb::delete_)(std::bind_front(
2979 handleLogServicesDumpEntryDelete, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002980}
2981
2982inline void requestRoutesBMCDumpCreate(App& app)
2983{
George Liu0fda0f12021-11-16 10:06:17 +08002984 BMCWEB_ROUTE(
2985 app,
2986 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07002987 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002988 .methods(boost::beast::http::verb::post)(
Claire Weinanfdd26902022-03-01 14:18:25 -08002989 std::bind_front(handleLogServicesDumpCollectDiagnosticDataPost,
2990 std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002991}
2992
2993inline void requestRoutesBMCDumpClear(App& app)
2994{
George Liu0fda0f12021-11-16 10:06:17 +08002995 BMCWEB_ROUTE(
2996 app,
2997 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07002998 .privileges(redfish::privileges::postLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002999 .methods(boost::beast::http::verb::post)(std::bind_front(
3000 handleLogServicesDumpClearLogPost, std::ref(app), "BMC"));
3001}
3002
3003inline void requestRoutesFaultLogDumpService(App& app)
3004{
3005 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/")
3006 .privileges(redfish::privileges::getLogService)
3007 .methods(boost::beast::http::verb::get)(std::bind_front(
3008 handleLogServicesDumpServiceGet, std::ref(app), "FaultLog"));
3009}
3010
3011inline void requestRoutesFaultLogDumpEntryCollection(App& app)
3012{
3013 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/")
3014 .privileges(redfish::privileges::getLogEntryCollection)
3015 .methods(boost::beast::http::verb::get)(
3016 std::bind_front(handleLogServicesDumpEntriesCollectionGet,
3017 std::ref(app), "FaultLog"));
3018}
3019
3020inline void requestRoutesFaultLogDumpEntry(App& app)
3021{
3022 BMCWEB_ROUTE(app,
3023 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
3024 .privileges(redfish::privileges::getLogEntry)
3025 .methods(boost::beast::http::verb::get)(std::bind_front(
3026 handleLogServicesDumpEntryGet, std::ref(app), "FaultLog"));
3027
3028 BMCWEB_ROUTE(app,
3029 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
3030 .privileges(redfish::privileges::deleteLogEntry)
3031 .methods(boost::beast::http::verb::delete_)(std::bind_front(
3032 handleLogServicesDumpEntryDelete, std::ref(app), "FaultLog"));
3033}
3034
3035inline void requestRoutesFaultLogDumpClear(App& app)
3036{
3037 BMCWEB_ROUTE(
3038 app,
3039 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Actions/LogService.ClearLog/")
3040 .privileges(redfish::privileges::postLogService)
3041 .methods(boost::beast::http::verb::post)(std::bind_front(
3042 handleLogServicesDumpClearLogPost, std::ref(app), "FaultLog"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003043}
3044
3045inline void requestRoutesSystemDumpService(App& app)
3046{
Ed Tanous22d268c2022-05-19 09:39:07 -07003047 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07003048 .privileges(redfish::privileges::getLogService)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003049 .methods(boost::beast::http::verb::get)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003050 handleLogServicesDumpServiceComputerSystemGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003051}
3052
3053inline void requestRoutesSystemDumpEntryCollection(App& app)
3054{
Ed Tanous22d268c2022-05-19 09:39:07 -07003055 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07003056 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous22d268c2022-05-19 09:39:07 -07003057 .methods(boost::beast::http::verb::get)(std::bind_front(
3058 handleLogServicesDumpEntriesCollectionComputerSystemGet,
3059 std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003060}
3061
3062inline void requestRoutesSystemDumpEntry(App& app)
3063{
3064 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003065 "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003066 .privileges(redfish::privileges::getLogEntry)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003067 .methods(boost::beast::http::verb::get)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003068 handleLogServicesDumpEntryComputerSystemGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003069
3070 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003071 "/redfish/v1/Systems/<str>/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003072 .privileges(redfish::privileges::deleteLogEntry)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003073 .methods(boost::beast::http::verb::delete_)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003074 handleLogServicesDumpEntryComputerSystemDelete, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003075}
3076
3077inline void requestRoutesSystemDumpCreate(App& app)
3078{
George Liu0fda0f12021-11-16 10:06:17 +08003079 BMCWEB_ROUTE(
3080 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003081 "/redfish/v1/Systems/<str>/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07003082 .privileges(redfish::privileges::postLogService)
Ed Tanous22d268c2022-05-19 09:39:07 -07003083 .methods(boost::beast::http::verb::post)(std::bind_front(
3084 handleLogServicesDumpCollectDiagnosticDataComputerSystemPost,
3085 std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003086}
3087
3088inline void requestRoutesSystemDumpClear(App& app)
3089{
George Liu0fda0f12021-11-16 10:06:17 +08003090 BMCWEB_ROUTE(
3091 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003092 "/redfish/v1/Systems/<str>/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003093 .privileges(redfish::privileges::postLogService)
Claire Weinan6ab9ad52022-08-12 18:20:17 -07003094 .methods(boost::beast::http::verb::post)(std::bind_front(
Ed Tanous22d268c2022-05-19 09:39:07 -07003095 handleLogServicesDumpClearLogComputerSystemPost, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003096}
3097
3098inline void requestRoutesCrashdumpService(App& app)
3099{
3100 // Note: Deviated from redfish privilege registry for GET & HEAD
3101 // method for security reasons.
3102 /**
3103 * Functions triggers appropriate requests on DBus
3104 */
Ed Tanous22d268c2022-05-19 09:39:07 -07003105 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/Crashdump/")
Ed Tanoused398212021-06-09 17:05:54 -07003106 // This is incorrect, should be:
3107 //.privileges(redfish::privileges::getLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003108 .privileges({{"ConfigureManager"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003109 .methods(boost::beast::http::verb::get)(
3110 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003111 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3112 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003113 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003114 {
3115 return;
3116 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003117 if constexpr (bmcwebEnableMultiHost)
3118 {
3119 // Option currently returns no systems. TBD
3120 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3121 systemName);
3122 return;
3123 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003124 if (systemName != "system")
3125 {
3126 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3127 systemName);
3128 return;
3129 }
3130
Ed Tanous002d39b2022-05-31 08:59:27 -07003131 // Copy over the static data to include the entries added by
3132 // SubRoute
3133 asyncResp->res.jsonValue["@odata.id"] =
3134 "/redfish/v1/Systems/system/LogServices/Crashdump";
3135 asyncResp->res.jsonValue["@odata.type"] =
3136 "#LogService.v1_2_0.LogService";
3137 asyncResp->res.jsonValue["Name"] = "Open BMC Oem Crashdump Service";
3138 asyncResp->res.jsonValue["Description"] = "Oem Crashdump Service";
V-Sanjana15b89722023-05-11 16:27:03 +05303139 asyncResp->res.jsonValue["Id"] = "Crashdump";
Ed Tanous002d39b2022-05-31 08:59:27 -07003140 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
3141 asyncResp->res.jsonValue["MaxNumberOfRecords"] = 3;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303142
Ed Tanous002d39b2022-05-31 08:59:27 -07003143 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07003144 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07003145 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
3146 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
3147 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303148
Ed Tanous002d39b2022-05-31 08:59:27 -07003149 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
Ed Tanousef4c65b2023-04-24 15:28:50 -07003150 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
Ed Tanous002d39b2022-05-31 08:59:27 -07003151 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
3152 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.ClearLog";
3153 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
3154 ["target"] =
3155 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData";
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003156 });
3157}
3158
3159void inline requestRoutesCrashdumpClear(App& app)
3160{
George Liu0fda0f12021-11-16 10:06:17 +08003161 BMCWEB_ROUTE(
3162 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003163 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003164 // This is incorrect, should be:
3165 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003166 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003167 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003168 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003169 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3170 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003171 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003172 {
3173 return;
3174 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003175 if constexpr (bmcwebEnableMultiHost)
3176 {
3177 // Option currently returns no systems. TBD
3178 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3179 systemName);
3180 return;
3181 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003182 if (systemName != "system")
3183 {
3184 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3185 systemName);
3186 return;
3187 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003188 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003189 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003190 const std::string&) {
3191 if (ec)
3192 {
3193 messages::internalError(asyncResp->res);
3194 return;
3195 }
3196 messages::success(asyncResp->res);
3197 },
3198 crashdumpObject, crashdumpPath, deleteAllInterface, "DeleteAll");
3199 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003200}
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07003201
zhanghch058d1b46d2021-04-01 11:18:24 +08003202static void
3203 logCrashdumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3204 const std::string& logID, nlohmann::json& logEntryJson)
Jason M. Billse855dd22019-10-08 11:37:48 -07003205{
Johnathan Mantey043a0532020-03-10 17:15:28 -07003206 auto getStoredLogCallback =
Ed Tanousb9d36b42022-02-26 21:42:46 -08003207 [asyncResp, logID,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003208 &logEntryJson](const boost::system::error_code& ec,
Ed Tanousb9d36b42022-02-26 21:42:46 -08003209 const dbus::utility::DBusPropertiesMap& params) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003210 if (ec)
3211 {
Ed Tanous62598e32023-07-17 17:06:25 -07003212 BMCWEB_LOG_DEBUG("failed to get log ec: {}", ec.message());
Ed Tanous002d39b2022-05-31 08:59:27 -07003213 if (ec.value() ==
3214 boost::system::linux_error::bad_request_descriptor)
Jason M. Bills1ddcf012019-11-26 14:59:21 -08003215 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003216 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003217 }
3218 else
3219 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003220 messages::internalError(asyncResp->res);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003221 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003222 return;
3223 }
3224
3225 std::string timestamp{};
3226 std::string filename{};
3227 std::string logfile{};
3228 parseCrashdumpParameters(params, filename, timestamp, logfile);
3229
3230 if (filename.empty() || timestamp.empty())
3231 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003232 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003233 return;
3234 }
3235
3236 std::string crashdumpURI =
3237 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/" +
3238 logID + "/" + filename;
Jason M. Bills84afc482022-06-24 12:38:23 -07003239 nlohmann::json::object_t logEntry;
Vijay Lobo9c11a172021-10-07 16:53:16 -05003240 logEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07003241 logEntry["@odata.id"] = boost::urls::format(
3242 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/{}",
3243 logID);
Jason M. Bills84afc482022-06-24 12:38:23 -07003244 logEntry["Name"] = "CPU Crashdump";
3245 logEntry["Id"] = logID;
3246 logEntry["EntryType"] = "Oem";
3247 logEntry["AdditionalDataURI"] = std::move(crashdumpURI);
3248 logEntry["DiagnosticDataType"] = "OEM";
3249 logEntry["OEMDiagnosticDataType"] = "PECICrashdump";
3250 logEntry["Created"] = std::move(timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07003251
3252 // If logEntryJson references an array of LogEntry resources
3253 // ('Members' list), then push this as a new entry, otherwise set it
3254 // directly
3255 if (logEntryJson.is_array())
3256 {
3257 logEntryJson.push_back(logEntry);
3258 asyncResp->res.jsonValue["Members@odata.count"] =
3259 logEntryJson.size();
3260 }
3261 else
3262 {
Jason M. Billsd405bb52022-06-24 10:52:05 -07003263 logEntryJson.update(logEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07003264 }
3265 };
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02003266 sdbusplus::asio::getAllProperties(
3267 *crow::connections::systemBus, crashdumpObject,
3268 crashdumpPath + std::string("/") + logID, crashdumpInterface,
3269 std::move(getStoredLogCallback));
Jason M. Billse855dd22019-10-08 11:37:48 -07003270}
3271
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003272inline void requestRoutesCrashdumpEntryCollection(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07003273{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003274 // Note: Deviated from redfish privilege registry for GET & HEAD
3275 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07003276 /**
3277 * Functions triggers appropriate requests on DBus
3278 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003279 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003280 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07003281 // This is incorrect, should be.
3282 //.privileges(redfish::privileges::postLogEntryCollection)
Ed Tanous432a8902021-06-14 15:28:56 -07003283 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003284 .methods(boost::beast::http::verb::get)(
3285 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003286 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3287 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003288 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003289 {
3290 return;
3291 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003292 if constexpr (bmcwebEnableMultiHost)
3293 {
3294 // Option currently returns no systems. TBD
3295 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3296 systemName);
3297 return;
3298 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003299 if (systemName != "system")
3300 {
3301 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3302 systemName);
3303 return;
3304 }
3305
George Liu7a1dbc42022-12-07 16:03:22 +08003306 constexpr std::array<std::string_view, 1> interfaces = {
3307 crashdumpInterface};
3308 dbus::utility::getSubTreePaths(
3309 "/", 0, interfaces,
3310 [asyncResp](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003311 const std::vector<std::string>& resp) {
3312 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07003313 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003314 if (ec.value() !=
3315 boost::system::errc::no_such_file_or_directory)
3316 {
Ed Tanous62598e32023-07-17 17:06:25 -07003317 BMCWEB_LOG_DEBUG("failed to get entries ec: {}",
3318 ec.message());
Ed Tanous002d39b2022-05-31 08:59:27 -07003319 messages::internalError(asyncResp->res);
3320 return;
3321 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07003322 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003323 asyncResp->res.jsonValue["@odata.type"] =
3324 "#LogEntryCollection.LogEntryCollection";
3325 asyncResp->res.jsonValue["@odata.id"] =
3326 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
3327 asyncResp->res.jsonValue["Name"] = "Open BMC Crashdump Entries";
3328 asyncResp->res.jsonValue["Description"] =
3329 "Collection of Crashdump Entries";
3330 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3331 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Jason M. Bills2b20ef62022-01-06 15:48:07 -08003332
Ed Tanous002d39b2022-05-31 08:59:27 -07003333 for (const std::string& path : resp)
3334 {
3335 const sdbusplus::message::object_path objPath(path);
3336 // Get the log ID
3337 std::string logID = objPath.filename();
3338 if (logID.empty())
3339 {
3340 continue;
3341 }
3342 // Add the log entry to the array
3343 logCrashdumpEntry(asyncResp, logID,
3344 asyncResp->res.jsonValue["Members"]);
3345 }
George Liu7a1dbc42022-12-07 16:03:22 +08003346 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003347 });
3348}
Ed Tanous1da66f72018-07-27 16:13:37 -07003349
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003350inline void requestRoutesCrashdumpEntry(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07003351{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003352 // Note: Deviated from redfish privilege registry for GET & HEAD
3353 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07003354
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003355 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07003356 app, "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003357 // this is incorrect, should be
3358 // .privileges(redfish::privileges::getLogEntry)
Ed Tanous432a8902021-06-14 15:28:56 -07003359 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003360 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003361 [&app](const crow::Request& req,
3362 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07003363 const std::string& systemName, const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003364 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003365 {
3366 return;
3367 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003368 if constexpr (bmcwebEnableMultiHost)
3369 {
3370 // Option currently returns no systems. TBD
3371 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3372 systemName);
3373 return;
3374 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003375 if (systemName != "system")
3376 {
3377 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3378 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003379 return;
3380 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003381 const std::string& logID = param;
3382 logCrashdumpEntry(asyncResp, logID, asyncResp->res.jsonValue);
3383 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003384}
Ed Tanous1da66f72018-07-27 16:13:37 -07003385
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003386inline void requestRoutesCrashdumpFile(App& app)
3387{
3388 // Note: Deviated from redfish privilege registry for GET & HEAD
3389 // method for security reasons.
3390 BMCWEB_ROUTE(
3391 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003392 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Entries/<str>/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003393 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003394 .methods(boost::beast::http::verb::get)(
Nan Zhoua4ce1142022-08-02 18:45:25 +00003395 [](const crow::Request& req,
3396 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07003397 const std::string& systemName, const std::string& logID,
3398 const std::string& fileName) {
Shounak Mitra2a9beee2022-07-20 18:41:30 +00003399 // Do not call getRedfishRoute here since the crashdump file is not a
3400 // Redfish resource.
Ed Tanous22d268c2022-05-19 09:39:07 -07003401
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003402 if constexpr (bmcwebEnableMultiHost)
3403 {
3404 // Option currently returns no systems. TBD
3405 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3406 systemName);
3407 return;
3408 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003409 if (systemName != "system")
3410 {
3411 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3412 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003413 return;
3414 }
3415
Ed Tanous002d39b2022-05-31 08:59:27 -07003416 auto getStoredLogCallback =
Ed Tanous39662a32023-02-06 15:09:46 -08003417 [asyncResp, logID, fileName, url(boost::urls::url(req.url()))](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003418 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003419 const std::vector<
3420 std::pair<std::string, dbus::utility::DbusVariantType>>&
3421 resp) {
3422 if (ec)
3423 {
Ed Tanous62598e32023-07-17 17:06:25 -07003424 BMCWEB_LOG_DEBUG("failed to get log ec: {}", ec.message());
Ed Tanous002d39b2022-05-31 08:59:27 -07003425 messages::internalError(asyncResp->res);
3426 return;
3427 }
Jason M. Bills8e6c0992021-03-11 16:26:53 -08003428
Ed Tanous002d39b2022-05-31 08:59:27 -07003429 std::string dbusFilename{};
3430 std::string dbusTimestamp{};
3431 std::string dbusFilepath{};
Jason M. Bills8e6c0992021-03-11 16:26:53 -08003432
Ed Tanous002d39b2022-05-31 08:59:27 -07003433 parseCrashdumpParameters(resp, dbusFilename, dbusTimestamp,
3434 dbusFilepath);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003435
Ed Tanous002d39b2022-05-31 08:59:27 -07003436 if (dbusFilename.empty() || dbusTimestamp.empty() ||
3437 dbusFilepath.empty())
3438 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003439 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003440 return;
3441 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003442
Ed Tanous002d39b2022-05-31 08:59:27 -07003443 // Verify the file name parameter is correct
3444 if (fileName != dbusFilename)
3445 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003446 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003447 return;
3448 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003449
Ed Tanous002d39b2022-05-31 08:59:27 -07003450 if (!std::filesystem::exists(dbusFilepath))
3451 {
Jiaqing Zhao9db4ba22022-10-09 17:24:40 +08003452 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Ed Tanous002d39b2022-05-31 08:59:27 -07003453 return;
3454 }
3455 std::ifstream ifs(dbusFilepath, std::ios::in | std::ios::binary);
3456 asyncResp->res.body() =
3457 std::string(std::istreambuf_iterator<char>{ifs}, {});
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003458
Ed Tanous002d39b2022-05-31 08:59:27 -07003459 // Configure this to be a file download when accessed
3460 // from a browser
Ed Tanousd9f6c622022-03-17 09:12:17 -07003461 asyncResp->res.addHeader(
3462 boost::beast::http::field::content_disposition, "attachment");
Ed Tanous002d39b2022-05-31 08:59:27 -07003463 };
Krzysztof Grobelnyd1bde9e2022-09-07 10:40:51 +02003464 sdbusplus::asio::getAllProperties(
3465 *crow::connections::systemBus, crashdumpObject,
3466 crashdumpPath + std::string("/") + logID, crashdumpInterface,
3467 std::move(getStoredLogCallback));
Ed Tanous002d39b2022-05-31 08:59:27 -07003468 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003469}
3470
Jason M. Billsc5a4c822022-01-06 15:51:23 -08003471enum class OEMDiagnosticType
3472{
3473 onDemand,
3474 telemetry,
3475 invalid,
3476};
3477
Ed Tanous26ccae32023-02-16 10:28:44 -08003478inline OEMDiagnosticType getOEMDiagnosticType(std::string_view oemDiagStr)
Jason M. Billsc5a4c822022-01-06 15:51:23 -08003479{
3480 if (oemDiagStr == "OnDemand")
3481 {
3482 return OEMDiagnosticType::onDemand;
3483 }
3484 if (oemDiagStr == "Telemetry")
3485 {
3486 return OEMDiagnosticType::telemetry;
3487 }
3488
3489 return OEMDiagnosticType::invalid;
3490}
3491
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003492inline void requestRoutesCrashdumpCollect(App& app)
3493{
3494 // Note: Deviated from redfish privilege registry for GET & HEAD
3495 // method for security reasons.
George Liu0fda0f12021-11-16 10:06:17 +08003496 BMCWEB_ROUTE(
3497 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003498 "/redfish/v1/Systems/<str>/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07003499 // The below is incorrect; Should be ConfigureManager
3500 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003501 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003502 .methods(boost::beast::http::verb::post)(
3503 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003504 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3505 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003506 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003507 {
3508 return;
3509 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003510
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003511 if constexpr (bmcwebEnableMultiHost)
3512 {
3513 // Option currently returns no systems. TBD
3514 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3515 systemName);
3516 return;
3517 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003518 if (systemName != "system")
3519 {
3520 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3521 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003522 return;
3523 }
3524
Ed Tanous002d39b2022-05-31 08:59:27 -07003525 std::string diagnosticDataType;
3526 std::string oemDiagnosticDataType;
3527 if (!redfish::json_util::readJsonAction(
3528 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
3529 "OEMDiagnosticDataType", oemDiagnosticDataType))
3530 {
3531 return;
3532 }
3533
3534 if (diagnosticDataType != "OEM")
3535 {
Ed Tanous62598e32023-07-17 17:06:25 -07003536 BMCWEB_LOG_ERROR(
3537 "Only OEM DiagnosticDataType supported for Crashdump");
Ed Tanous002d39b2022-05-31 08:59:27 -07003538 messages::actionParameterValueFormatError(
3539 asyncResp->res, diagnosticDataType, "DiagnosticDataType",
3540 "CollectDiagnosticData");
3541 return;
3542 }
3543
3544 OEMDiagnosticType oemDiagType =
3545 getOEMDiagnosticType(oemDiagnosticDataType);
3546
3547 std::string iface;
3548 std::string method;
3549 std::string taskMatchStr;
3550 if (oemDiagType == OEMDiagnosticType::onDemand)
3551 {
3552 iface = crashdumpOnDemandInterface;
3553 method = "GenerateOnDemandLog";
3554 taskMatchStr = "type='signal',"
3555 "interface='org.freedesktop.DBus.Properties',"
3556 "member='PropertiesChanged',"
3557 "arg0namespace='com.intel.crashdump'";
3558 }
3559 else if (oemDiagType == OEMDiagnosticType::telemetry)
3560 {
3561 iface = crashdumpTelemetryInterface;
3562 method = "GenerateTelemetryLog";
3563 taskMatchStr = "type='signal',"
3564 "interface='org.freedesktop.DBus.Properties',"
3565 "member='PropertiesChanged',"
3566 "arg0namespace='com.intel.crashdump'";
3567 }
3568 else
3569 {
Ed Tanous62598e32023-07-17 17:06:25 -07003570 BMCWEB_LOG_ERROR("Unsupported OEMDiagnosticDataType: {}",
3571 oemDiagnosticDataType);
Ed Tanous002d39b2022-05-31 08:59:27 -07003572 messages::actionParameterValueFormatError(
3573 asyncResp->res, oemDiagnosticDataType, "OEMDiagnosticDataType",
3574 "CollectDiagnosticData");
3575 return;
3576 }
3577
3578 auto collectCrashdumpCallback =
3579 [asyncResp, payload(task::Payload(req)),
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003580 taskMatchStr](const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07003581 const std::string&) mutable {
3582 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07003583 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003584 if (ec.value() == boost::system::errc::operation_not_supported)
3585 {
3586 messages::resourceInStandby(asyncResp->res);
3587 }
3588 else if (ec.value() ==
3589 boost::system::errc::device_or_resource_busy)
3590 {
3591 messages::serviceTemporarilyUnavailable(asyncResp->res,
3592 "60");
3593 }
3594 else
3595 {
3596 messages::internalError(asyncResp->res);
3597 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07003598 return;
3599 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003600 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
Ed Tanous8b242752023-06-27 17:17:13 -07003601 [](const boost::system::error_code& ec2, sdbusplus::message_t&,
Ed Tanous002d39b2022-05-31 08:59:27 -07003602 const std::shared_ptr<task::TaskData>& taskData) {
Ed Tanous8b242752023-06-27 17:17:13 -07003603 if (!ec2)
Ed Tanous002d39b2022-05-31 08:59:27 -07003604 {
3605 taskData->messages.emplace_back(messages::taskCompletedOK(
3606 std::to_string(taskData->index)));
3607 taskData->state = "Completed";
3608 }
3609 return task::completed;
3610 },
3611 taskMatchStr);
Ed Tanous1da66f72018-07-27 16:13:37 -07003612
Ed Tanous002d39b2022-05-31 08:59:27 -07003613 task->startTimer(std::chrono::minutes(5));
3614 task->populateResp(asyncResp->res);
3615 task->payload.emplace(std::move(payload));
3616 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003617
Ed Tanous002d39b2022-05-31 08:59:27 -07003618 crow::connections::systemBus->async_method_call(
3619 std::move(collectCrashdumpCallback), crashdumpObject, crashdumpPath,
3620 iface, method);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003621 });
3622}
Kenny L. Ku6eda7682020-06-19 09:48:36 -07003623
Andrew Geisslercb92c032018-08-17 07:56:14 -07003624/**
3625 * DBusLogServiceActionsClear class supports POST method for ClearLog action.
3626 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003627inline void requestRoutesDBusLogServiceActionsClear(App& app)
Andrew Geisslercb92c032018-08-17 07:56:14 -07003628{
Andrew Geisslercb92c032018-08-17 07:56:14 -07003629 /**
3630 * Function handles POST method request.
3631 * The Clear Log actions does not require any parameter.The action deletes
3632 * all entries found in the Entries collection for this Log Service.
3633 */
Andrew Geisslercb92c032018-08-17 07:56:14 -07003634
George Liu0fda0f12021-11-16 10:06:17 +08003635 BMCWEB_ROUTE(
3636 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003637 "/redfish/v1/Systems/<str>/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003638 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003639 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003640 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003641 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3642 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003643 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003644 {
3645 return;
3646 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003647 if constexpr (bmcwebEnableMultiHost)
3648 {
3649 // Option currently returns no systems. TBD
3650 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3651 systemName);
3652 return;
3653 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003654 if (systemName != "system")
3655 {
3656 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3657 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003658 return;
3659 }
Ed Tanous62598e32023-07-17 17:06:25 -07003660 BMCWEB_LOG_DEBUG("Do delete all entries.");
Andrew Geisslercb92c032018-08-17 07:56:14 -07003661
Ed Tanous002d39b2022-05-31 08:59:27 -07003662 // Process response from Logging service.
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003663 auto respHandler = [asyncResp](const boost::system::error_code& ec) {
Ed Tanous62598e32023-07-17 17:06:25 -07003664 BMCWEB_LOG_DEBUG("doClearLog resp_handler callback: Done");
Ed Tanous002d39b2022-05-31 08:59:27 -07003665 if (ec)
3666 {
3667 // TODO Handle for specific error code
Ed Tanous62598e32023-07-17 17:06:25 -07003668 BMCWEB_LOG_ERROR("doClearLog resp_handler got error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07003669 asyncResp->res.result(
3670 boost::beast::http::status::internal_server_error);
3671 return;
3672 }
Andrew Geisslercb92c032018-08-17 07:56:14 -07003673
Ed Tanous002d39b2022-05-31 08:59:27 -07003674 asyncResp->res.result(boost::beast::http::status::no_content);
3675 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003676
Ed Tanous002d39b2022-05-31 08:59:27 -07003677 // Make call to Logging service to request Clear Log
3678 crow::connections::systemBus->async_method_call(
3679 respHandler, "xyz.openbmc_project.Logging",
3680 "/xyz/openbmc_project/logging",
3681 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3682 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003683}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003684
3685/****************************************************
3686 * Redfish PostCode interfaces
3687 * using DBUS interface: getPostCodesTS
3688 ******************************************************/
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003689inline void requestRoutesPostCodesLogService(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003690{
Ed Tanous22d268c2022-05-19 09:39:07 -07003691 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/LogServices/PostCodes/")
Ed Tanoused398212021-06-09 17:05:54 -07003692 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07003693 .methods(boost::beast::http::verb::get)(
3694 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003695 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3696 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003697 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003698 {
3699 return;
3700 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003701 if constexpr (bmcwebEnableMultiHost)
3702 {
3703 // Option currently returns no systems. TBD
3704 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3705 systemName);
3706 return;
3707 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003708 if (systemName != "system")
3709 {
3710 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3711 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003712 return;
3713 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003714 asyncResp->res.jsonValue["@odata.id"] =
3715 "/redfish/v1/Systems/system/LogServices/PostCodes";
3716 asyncResp->res.jsonValue["@odata.type"] =
3717 "#LogService.v1_1_0.LogService";
3718 asyncResp->res.jsonValue["Name"] = "POST Code Log Service";
3719 asyncResp->res.jsonValue["Description"] = "POST Code Log Service";
Ed Tanoused34a4a2023-02-08 15:43:27 -08003720 asyncResp->res.jsonValue["Id"] = "PostCodes";
Ed Tanous002d39b2022-05-31 08:59:27 -07003721 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
3722 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
3723 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
Tejas Patil7c8c4052021-06-04 17:43:14 +05303724
Ed Tanous002d39b2022-05-31 08:59:27 -07003725 std::pair<std::string, std::string> redfishDateTimeOffset =
Ed Tanous2b829372022-08-03 14:22:34 -07003726 redfish::time_utils::getDateTimeOffsetNow();
Ed Tanous002d39b2022-05-31 08:59:27 -07003727 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
3728 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
3729 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303730
Ed Tanous002d39b2022-05-31 08:59:27 -07003731 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
3732 {"target",
3733 "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/LogService.ClearLog"}};
George Liu0fda0f12021-11-16 10:06:17 +08003734 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003735}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003736
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003737inline void requestRoutesPostCodesClear(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003738{
George Liu0fda0f12021-11-16 10:06:17 +08003739 BMCWEB_ROUTE(
3740 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07003741 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003742 // The following privilege is incorrect; It should be ConfigureManager
3743 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003744 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003745 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003746 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07003747 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3748 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003749 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003750 {
3751 return;
3752 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08003753 if constexpr (bmcwebEnableMultiHost)
3754 {
3755 // Option currently returns no systems. TBD
3756 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3757 systemName);
3758 return;
3759 }
Ed Tanous22d268c2022-05-19 09:39:07 -07003760 if (systemName != "system")
3761 {
3762 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
3763 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07003764 return;
3765 }
Ed Tanous62598e32023-07-17 17:06:25 -07003766 BMCWEB_LOG_DEBUG("Do delete all postcodes entries.");
ZhikuiRena3316fc2020-01-29 14:58:08 -08003767
Ed Tanous002d39b2022-05-31 08:59:27 -07003768 // Make call to post-code service to request clear all
3769 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003770 [asyncResp](const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003771 if (ec)
3772 {
3773 // TODO Handle for specific error code
Ed Tanous62598e32023-07-17 17:06:25 -07003774 BMCWEB_LOG_ERROR("doClearPostCodes resp_handler got error {}",
3775 ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07003776 asyncResp->res.result(
3777 boost::beast::http::status::internal_server_error);
3778 messages::internalError(asyncResp->res);
3779 return;
3780 }
3781 },
3782 "xyz.openbmc_project.State.Boot.PostCode0",
3783 "/xyz/openbmc_project/State/Boot/PostCode0",
3784 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3785 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003786}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003787
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003788/**
3789 * @brief Parse post code ID and get the current value and index value
3790 * eg: postCodeID=B1-2, currentValue=1, index=2
3791 *
3792 * @param[in] postCodeID Post Code ID
3793 * @param[out] currentValue Current value
3794 * @param[out] index Index value
3795 *
3796 * @return bool true if the parsing is successful, false the parsing fails
3797 */
3798inline static bool parsePostCode(const std::string& postCodeID,
3799 uint64_t& currentValue, uint16_t& index)
3800{
3801 std::vector<std::string> split;
Ed Tanous50ebd4a2023-01-19 19:03:17 -08003802 bmcweb::split(split, postCodeID, '-');
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003803 if (split.size() != 2 || split[0].length() < 2 || split[0].front() != 'B')
3804 {
3805 return false;
3806 }
3807
Patrick Williams84396af2023-05-11 11:47:45 -05003808 auto start = std::next(split[0].begin());
3809 auto end = split[0].end();
3810 auto [ptrIndex, ecIndex] = std::from_chars(&*start, &*end, index);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003811
Patrick Williams84396af2023-05-11 11:47:45 -05003812 if (ptrIndex != &*end || ecIndex != std::errc())
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003813 {
3814 return false;
3815 }
3816
Patrick Williams84396af2023-05-11 11:47:45 -05003817 start = split[1].begin();
3818 end = split[1].end();
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003819
Patrick Williams84396af2023-05-11 11:47:45 -05003820 auto [ptrValue, ecValue] = std::from_chars(&*start, &*end, currentValue);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003821
Patrick Williams84396af2023-05-11 11:47:45 -05003822 return ptrValue == &*end && ecValue == std::errc();
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003823}
3824
3825static bool fillPostCodeEntry(
Ed Tanousac106bf2023-06-07 09:24:59 -07003826 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303827 const boost::container::flat_map<
3828 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>& postcode,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003829 const uint16_t bootIndex, const uint64_t codeIndex = 0,
3830 const uint64_t skip = 0, const uint64_t top = 0)
3831{
3832 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08003833 const registries::Message* message =
3834 registries::getMessage("OpenBMC.0.2.BIOSPOSTCode");
ZhikuiRena3316fc2020-01-29 14:58:08 -08003835
3836 uint64_t currentCodeIndex = 0;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003837 uint64_t firstCodeTimeUs = 0;
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303838 for (const std::pair<uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3839 code : postcode)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003840 {
3841 currentCodeIndex++;
3842 std::string postcodeEntryID =
3843 "B" + std::to_string(bootIndex) + "-" +
3844 std::to_string(currentCodeIndex); // 1 based index in EntryID string
3845
3846 uint64_t usecSinceEpoch = code.first;
3847 uint64_t usTimeOffset = 0;
3848
3849 if (1 == currentCodeIndex)
3850 { // already incremented
3851 firstCodeTimeUs = code.first;
3852 }
3853 else
3854 {
3855 usTimeOffset = code.first - firstCodeTimeUs;
3856 }
3857
3858 // skip if no specific codeIndex is specified and currentCodeIndex does
3859 // not fall between top and skip
3860 if ((codeIndex == 0) &&
3861 (currentCodeIndex <= skip || currentCodeIndex > top))
3862 {
3863 continue;
3864 }
3865
Gunnar Mills4e0453b2020-07-08 14:00:30 -05003866 // skip if a specific codeIndex is specified and does not match the
ZhikuiRena3316fc2020-01-29 14:58:08 -08003867 // currentIndex
3868 if ((codeIndex > 0) && (currentCodeIndex != codeIndex))
3869 {
3870 // This is done for simplicity. 1st entry is needed to calculate
3871 // time offset. To improve efficiency, one can get to the entry
3872 // directly (possibly with flatmap's nth method)
3873 continue;
3874 }
3875
3876 // currentCodeIndex is within top and skip or equal to specified code
3877 // index
3878
3879 // Get the Created time from the timestamp
3880 std::string entryTimeStr;
Konstantin Aladyshev2a025612023-02-15 11:52:58 +03003881 entryTimeStr = redfish::time_utils::getDateTimeUintUs(usecSinceEpoch);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003882
3883 // assemble messageArgs: BootIndex, TimeOffset(100us), PostCode(hex)
3884 std::ostringstream hexCode;
3885 hexCode << "0x" << std::setfill('0') << std::setw(2) << std::hex
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303886 << std::get<0>(code.second);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003887 std::ostringstream timeOffsetStr;
3888 // Set Fixed -Point Notation
3889 timeOffsetStr << std::fixed;
3890 // Set precision to 4 digits
3891 timeOffsetStr << std::setprecision(4);
3892 // Add double to stream
3893 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003894
Ed Tanous1e6deaf2022-02-17 11:32:37 -08003895 std::string bootIndexStr = std::to_string(bootIndex);
3896 std::string timeOffsetString = timeOffsetStr.str();
3897 std::string hexCodeStr = hexCode.str();
3898
3899 std::array<std::string_view, 3> messageArgs = {
3900 bootIndexStr, timeOffsetString, hexCodeStr};
3901
3902 std::string msg =
3903 redfish::registries::fillMessageArgs(messageArgs, message->message);
3904 if (msg.empty())
ZhikuiRena3316fc2020-01-29 14:58:08 -08003905 {
Ed Tanous1e6deaf2022-02-17 11:32:37 -08003906 messages::internalError(asyncResp->res);
3907 return false;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003908 }
3909
Tim Leed4342a92020-04-27 11:47:58 +08003910 // Get Severity template from message registry
3911 std::string severity;
3912 if (message != nullptr)
3913 {
Ed Tanous5f2b84e2022-02-08 00:41:53 -08003914 severity = message->messageSeverity;
Tim Leed4342a92020-04-27 11:47:58 +08003915 }
3916
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003917 // Format entry
3918 nlohmann::json::object_t bmcLogEntry;
Vijay Lobo9c11a172021-10-07 16:53:16 -05003919 bmcLogEntry["@odata.type"] = "#LogEntry.v1_9_0.LogEntry";
Ed Tanousef4c65b2023-04-24 15:28:50 -07003920 bmcLogEntry["@odata.id"] = boost::urls::format(
3921 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/{}",
3922 postcodeEntryID);
Jason M. Bills84afc482022-06-24 12:38:23 -07003923 bmcLogEntry["Name"] = "POST Code Log Entry";
3924 bmcLogEntry["Id"] = postcodeEntryID;
3925 bmcLogEntry["Message"] = std::move(msg);
3926 bmcLogEntry["MessageId"] = "OpenBMC.0.2.BIOSPOSTCode";
Ed Tanous1e6deaf2022-02-17 11:32:37 -08003927 bmcLogEntry["MessageArgs"] = messageArgs;
Jason M. Bills84afc482022-06-24 12:38:23 -07003928 bmcLogEntry["EntryType"] = "Event";
3929 bmcLogEntry["Severity"] = std::move(severity);
3930 bmcLogEntry["Created"] = entryTimeStr;
George Liu647b3cd2021-07-05 12:43:56 +08003931 if (!std::get<std::vector<uint8_t>>(code.second).empty())
3932 {
3933 bmcLogEntry["AdditionalDataURI"] =
3934 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/" +
3935 postcodeEntryID + "/attachment";
3936 }
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003937
3938 // codeIndex is only specified when querying single entry, return only
3939 // that entry in this case
3940 if (codeIndex != 0)
3941 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003942 asyncResp->res.jsonValue.update(bmcLogEntry);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003943 return true;
3944 }
3945
Ed Tanousac106bf2023-06-07 09:24:59 -07003946 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
Patrick Williamsb2ba3072023-05-12 10:27:39 -05003947 logEntryArray.emplace_back(std::move(bmcLogEntry));
ZhikuiRena3316fc2020-01-29 14:58:08 -08003948 }
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003949
3950 // Return value is always false when querying multiple entries
3951 return false;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003952}
3953
Ed Tanousac106bf2023-06-07 09:24:59 -07003954static void
3955 getPostCodeForEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3956 const std::string& entryId)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003957{
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003958 uint16_t bootIndex = 0;
3959 uint64_t codeIndex = 0;
3960 if (!parsePostCode(entryId, codeIndex, bootIndex))
3961 {
3962 // Requested ID was not found
Ed Tanousac106bf2023-06-07 09:24:59 -07003963 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003964 return;
3965 }
3966
3967 if (bootIndex == 0 || codeIndex == 0)
3968 {
3969 // 0 is an invalid index
Ed Tanousac106bf2023-06-07 09:24:59 -07003970 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003971 return;
3972 }
3973
ZhikuiRena3316fc2020-01-29 14:58:08 -08003974 crow::connections::systemBus->async_method_call(
Ed Tanousac106bf2023-06-07 09:24:59 -07003975 [asyncResp, entryId, bootIndex,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08003976 codeIndex](const boost::system::error_code& ec,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303977 const boost::container::flat_map<
3978 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3979 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003980 if (ec)
3981 {
Ed Tanous62598e32023-07-17 17:06:25 -07003982 BMCWEB_LOG_DEBUG("DBUS POST CODE PostCode response error");
Ed Tanousac106bf2023-06-07 09:24:59 -07003983 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07003984 return;
3985 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003986
Ed Tanous002d39b2022-05-31 08:59:27 -07003987 if (postcode.empty())
3988 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003989 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Ed Tanous002d39b2022-05-31 08:59:27 -07003990 return;
3991 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003992
Ed Tanousac106bf2023-06-07 09:24:59 -07003993 if (!fillPostCodeEntry(asyncResp, postcode, bootIndex, codeIndex))
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003994 {
Ed Tanousac106bf2023-06-07 09:24:59 -07003995 messages::resourceNotFound(asyncResp->res, "LogEntry", entryId);
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08003996 return;
3997 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003998 },
Jonathan Doman15124762021-01-07 17:54:17 -08003999 "xyz.openbmc_project.State.Boot.PostCode0",
4000 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08004001 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
4002 bootIndex);
4003}
4004
Ed Tanousac106bf2023-06-07 09:24:59 -07004005static void
4006 getPostCodeForBoot(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
4007 const uint16_t bootIndex, const uint16_t bootCount,
4008 const uint64_t entryCount, size_t skip, size_t top)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004009{
4010 crow::connections::systemBus->async_method_call(
Ed Tanousac106bf2023-06-07 09:24:59 -07004011 [asyncResp, bootIndex, bootCount, entryCount, skip,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08004012 top](const boost::system::error_code& ec,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05304013 const boost::container::flat_map<
4014 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
4015 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07004016 if (ec)
4017 {
Ed Tanous62598e32023-07-17 17:06:25 -07004018 BMCWEB_LOG_DEBUG("DBUS POST CODE PostCode response error");
Ed Tanousac106bf2023-06-07 09:24:59 -07004019 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07004020 return;
4021 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08004022
Ed Tanous002d39b2022-05-31 08:59:27 -07004023 uint64_t endCount = entryCount;
4024 if (!postcode.empty())
4025 {
4026 endCount = entryCount + postcode.size();
Ed Tanous3648c8b2022-07-25 13:39:59 -07004027 if (skip < endCount && (top + skip) > entryCount)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004028 {
Patrick Williams89492a12023-05-10 07:51:34 -05004029 uint64_t thisBootSkip = std::max(static_cast<uint64_t>(skip),
4030 entryCount) -
4031 entryCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07004032 uint64_t thisBootTop =
Ed Tanous3648c8b2022-07-25 13:39:59 -07004033 std::min(static_cast<uint64_t>(top + skip), endCount) -
4034 entryCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07004035
Ed Tanousac106bf2023-06-07 09:24:59 -07004036 fillPostCodeEntry(asyncResp, postcode, bootIndex, 0,
4037 thisBootSkip, thisBootTop);
ZhikuiRena3316fc2020-01-29 14:58:08 -08004038 }
Ed Tanousac106bf2023-06-07 09:24:59 -07004039 asyncResp->res.jsonValue["Members@odata.count"] = endCount;
Ed Tanous002d39b2022-05-31 08:59:27 -07004040 }
4041
4042 // continue to previous bootIndex
4043 if (bootIndex < bootCount)
4044 {
Ed Tanousac106bf2023-06-07 09:24:59 -07004045 getPostCodeForBoot(asyncResp, static_cast<uint16_t>(bootIndex + 1),
Ed Tanous002d39b2022-05-31 08:59:27 -07004046 bootCount, endCount, skip, top);
4047 }
Jiaqing Zhao81584ab2022-07-28 00:33:45 +08004048 else if (skip + top < endCount)
Ed Tanous002d39b2022-05-31 08:59:27 -07004049 {
Ed Tanousac106bf2023-06-07 09:24:59 -07004050 asyncResp->res.jsonValue["Members@odata.nextLink"] =
Ed Tanous002d39b2022-05-31 08:59:27 -07004051 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries?$skip=" +
4052 std::to_string(skip + top);
4053 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08004054 },
Jonathan Doman15124762021-01-07 17:54:17 -08004055 "xyz.openbmc_project.State.Boot.PostCode0",
4056 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08004057 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
4058 bootIndex);
4059}
4060
zhanghch058d1b46d2021-04-01 11:18:24 +08004061static void
Ed Tanousac106bf2023-06-07 09:24:59 -07004062 getCurrentBootNumber(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous3648c8b2022-07-25 13:39:59 -07004063 size_t skip, size_t top)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004064{
4065 uint64_t entryCount = 0;
Jonathan Doman1e1e5982021-06-11 09:36:17 -07004066 sdbusplus::asio::getProperty<uint16_t>(
4067 *crow::connections::systemBus,
4068 "xyz.openbmc_project.State.Boot.PostCode0",
4069 "/xyz/openbmc_project/State/Boot/PostCode0",
4070 "xyz.openbmc_project.State.Boot.PostCode", "CurrentBootCycleCount",
Ed Tanousac106bf2023-06-07 09:24:59 -07004071 [asyncResp, entryCount, skip, top](const boost::system::error_code& ec,
4072 const uint16_t bootCount) {
Ed Tanous002d39b2022-05-31 08:59:27 -07004073 if (ec)
4074 {
Ed Tanous62598e32023-07-17 17:06:25 -07004075 BMCWEB_LOG_DEBUG("DBUS response error {}", ec);
Ed Tanousac106bf2023-06-07 09:24:59 -07004076 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -07004077 return;
4078 }
Ed Tanousac106bf2023-06-07 09:24:59 -07004079 getPostCodeForBoot(asyncResp, 1, bootCount, entryCount, skip, top);
Jonathan Doman1e1e5982021-06-11 09:36:17 -07004080 });
ZhikuiRena3316fc2020-01-29 14:58:08 -08004081}
4082
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004083inline void requestRoutesPostCodesEntryCollection(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004084{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004085 BMCWEB_ROUTE(app,
Ed Tanous22d268c2022-05-19 09:39:07 -07004086 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07004087 .privileges(redfish::privileges::getLogEntryCollection)
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,
Ed Tanous22d268c2022-05-19 09:39:07 -07004090 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
4091 const std::string& systemName) {
Ed Tanous002d39b2022-05-31 08:59:27 -07004092 query_param::QueryCapabilities capabilities = {
4093 .canDelegateTop = true,
4094 .canDelegateSkip = true,
4095 };
4096 query_param::Query delegatedQuery;
4097 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00004098 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07004099 {
4100 return;
4101 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08004102 if constexpr (bmcwebEnableMultiHost)
4103 {
4104 // Option currently returns no systems. TBD
4105 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4106 systemName);
4107 return;
4108 }
Ed Tanous22d268c2022-05-19 09:39:07 -07004109
4110 if (systemName != "system")
4111 {
4112 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4113 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07004114 return;
4115 }
Ed Tanous002d39b2022-05-31 08:59:27 -07004116 asyncResp->res.jsonValue["@odata.type"] =
4117 "#LogEntryCollection.LogEntryCollection";
4118 asyncResp->res.jsonValue["@odata.id"] =
4119 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
4120 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
4121 asyncResp->res.jsonValue["Description"] =
4122 "Collection of POST Code Log Entries";
4123 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
4124 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Ed Tanous3648c8b2022-07-25 13:39:59 -07004125 size_t skip = delegatedQuery.skip.value_or(0);
Jiaqing Zhao5143f7a2022-07-22 09:33:33 +08004126 size_t top = delegatedQuery.top.value_or(query_param::Query::maxTop);
Ed Tanous3648c8b2022-07-25 13:39:59 -07004127 getCurrentBootNumber(asyncResp, skip, top);
Ed Tanous002d39b2022-05-31 08:59:27 -07004128 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004129}
ZhikuiRena3316fc2020-01-29 14:58:08 -08004130
George Liu647b3cd2021-07-05 12:43:56 +08004131inline void requestRoutesPostCodesEntryAdditionalData(App& app)
4132{
George Liu0fda0f12021-11-16 10:06:17 +08004133 BMCWEB_ROUTE(
4134 app,
Ed Tanous22d268c2022-05-19 09:39:07 -07004135 "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/<str>/attachment/")
George Liu647b3cd2021-07-05 12:43:56 +08004136 .privileges(redfish::privileges::getLogEntry)
4137 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07004138 [&app](const crow::Request& req,
4139 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07004140 const std::string& systemName,
Ed Tanous45ca1b82022-03-25 13:07:27 -07004141 const std::string& postCodeID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00004142 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07004143 {
4144 return;
4145 }
Matt Spinler72e21372023-04-19 12:53:33 -05004146 if (!http_helpers::isContentTypeAllowed(
Ed Tanous99351cd2022-08-07 16:42:51 -07004147 req.getHeaderValue("Accept"),
Ed Tanous4a0e1a02022-09-21 15:28:04 -07004148 http_helpers::ContentType::OctetStream, true))
Ed Tanous002d39b2022-05-31 08:59:27 -07004149 {
4150 asyncResp->res.result(boost::beast::http::status::bad_request);
4151 return;
4152 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08004153 if constexpr (bmcwebEnableMultiHost)
4154 {
4155 // Option currently returns no systems. TBD
4156 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4157 systemName);
4158 return;
4159 }
Ed Tanous22d268c2022-05-19 09:39:07 -07004160 if (systemName != "system")
4161 {
4162 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4163 systemName);
Ed Tanous22d268c2022-05-19 09:39:07 -07004164 return;
4165 }
George Liu647b3cd2021-07-05 12:43:56 +08004166
Ed Tanous002d39b2022-05-31 08:59:27 -07004167 uint64_t currentValue = 0;
4168 uint16_t index = 0;
4169 if (!parsePostCode(postCodeID, currentValue, index))
4170 {
4171 messages::resourceNotFound(asyncResp->res, "LogEntry", postCodeID);
4172 return;
4173 }
George Liu647b3cd2021-07-05 12:43:56 +08004174
Ed Tanous002d39b2022-05-31 08:59:27 -07004175 crow::connections::systemBus->async_method_call(
4176 [asyncResp, postCodeID, currentValue](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08004177 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07004178 const std::vector<std::tuple<uint64_t, std::vector<uint8_t>>>&
4179 postcodes) {
4180 if (ec.value() == EBADR)
4181 {
4182 messages::resourceNotFound(asyncResp->res, "LogEntry",
4183 postCodeID);
4184 return;
4185 }
4186 if (ec)
4187 {
Ed Tanous62598e32023-07-17 17:06:25 -07004188 BMCWEB_LOG_DEBUG("DBUS response error {}", ec);
Ed Tanous002d39b2022-05-31 08:59:27 -07004189 messages::internalError(asyncResp->res);
4190 return;
4191 }
George Liu647b3cd2021-07-05 12:43:56 +08004192
Ed Tanous002d39b2022-05-31 08:59:27 -07004193 size_t value = static_cast<size_t>(currentValue) - 1;
4194 if (value == std::string::npos || postcodes.size() < currentValue)
4195 {
Ed Tanous62598e32023-07-17 17:06:25 -07004196 BMCWEB_LOG_WARNING("Wrong currentValue value");
Ed Tanous002d39b2022-05-31 08:59:27 -07004197 messages::resourceNotFound(asyncResp->res, "LogEntry",
4198 postCodeID);
4199 return;
4200 }
George Liu647b3cd2021-07-05 12:43:56 +08004201
Ed Tanous002d39b2022-05-31 08:59:27 -07004202 const auto& [tID, c] = postcodes[value];
4203 if (c.empty())
4204 {
Ed Tanous62598e32023-07-17 17:06:25 -07004205 BMCWEB_LOG_WARNING("No found post code data");
Ed Tanous002d39b2022-05-31 08:59:27 -07004206 messages::resourceNotFound(asyncResp->res, "LogEntry",
4207 postCodeID);
4208 return;
4209 }
4210 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4211 const char* d = reinterpret_cast<const char*>(c.data());
4212 std::string_view strData(d, c.size());
George Liu647b3cd2021-07-05 12:43:56 +08004213
Ed Tanousd9f6c622022-03-17 09:12:17 -07004214 asyncResp->res.addHeader(boost::beast::http::field::content_type,
Ed Tanous002d39b2022-05-31 08:59:27 -07004215 "application/octet-stream");
Ed Tanousd9f6c622022-03-17 09:12:17 -07004216 asyncResp->res.addHeader(
4217 boost::beast::http::field::content_transfer_encoding, "Base64");
Ed Tanous002d39b2022-05-31 08:59:27 -07004218 asyncResp->res.body() = crow::utility::base64encode(strData);
4219 },
4220 "xyz.openbmc_project.State.Boot.PostCode0",
4221 "/xyz/openbmc_project/State/Boot/PostCode0",
4222 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodes", index);
4223 });
George Liu647b3cd2021-07-05 12:43:56 +08004224}
4225
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004226inline void requestRoutesPostCodesEntry(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08004227{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004228 BMCWEB_ROUTE(
Ed Tanous22d268c2022-05-19 09:39:07 -07004229 app, "/redfish/v1/Systems/<str>/LogServices/PostCodes/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07004230 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004231 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07004232 [&app](const crow::Request& req,
4233 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07004234 const std::string& systemName, const std::string& targetID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00004235 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07004236 {
4237 return;
4238 }
Ed Tanous7f3e84a2022-12-28 16:22:54 -08004239 if constexpr (bmcwebEnableMultiHost)
4240 {
4241 // Option currently returns no systems. TBD
4242 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4243 systemName);
4244 return;
4245 }
Ed Tanous22d268c2022-05-19 09:39:07 -07004246 if (systemName != "system")
4247 {
4248 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
4249 systemName);
4250 return;
4251 }
4252
Jiaqing Zhao6f284d22022-10-10 15:56:45 +08004253 getPostCodeForEntry(asyncResp, targetID);
Ed Tanous002d39b2022-05-31 08:59:27 -07004254 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07004255}
ZhikuiRena3316fc2020-01-29 14:58:08 -08004256
Ed Tanous1da66f72018-07-27 16:13:37 -07004257} // namespace redfish