blob: be2d887472eef1837a1fb727aa56a08503223e6e [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
Spencer Kub7028eb2021-10-26 15:27:35 +080018#include "gzfile.hpp"
George Liu647b3cd2021-07-05 12:43:56 +080019#include "http_utility.hpp"
Spencer Kub7028eb2021-10-26 15:27:35 +080020#include "human_sort.hpp"
Jason M. Bills4851d452019-03-28 11:27:48 -070021#include "registries.hpp"
22#include "registries/base_message_registry.hpp"
23#include "registries/openbmc_message_registry.hpp"
James Feist46229572020-02-19 15:11:58 -080024#include "task.hpp"
Ed Tanous1da66f72018-07-27 16:13:37 -070025
Jason M. Billse1f26342018-07-18 12:12:00 -070026#include <systemd/sd-journal.h>
Adriana Kobylak400fd1f2021-01-29 09:01:30 -060027#include <unistd.h>
Jason M. Billse1f26342018-07-18 12:12:00 -070028
John Edward Broadbent7e860f12021-04-08 15:57:16 -070029#include <app.hpp>
Adriana Kobylak400fd1f2021-01-29 09:01:30 -060030#include <boost/algorithm/string/replace.hpp>
Jason M. Bills4851d452019-03-28 11:27:48 -070031#include <boost/algorithm/string/split.hpp>
Adriana Kobylak400fd1f2021-01-29 09:01:30 -060032#include <boost/beast/http.hpp>
Ed Tanous1da66f72018-07-27 16:13:37 -070033#include <boost/container/flat_map.hpp>
Jason M. Bills1ddcf012019-11-26 14:59:21 -080034#include <boost/system/linux_error.hpp>
Ed Tanous168e20c2021-12-13 14:39:53 -080035#include <dbus_utility.hpp>
Andrew Geisslercb92c032018-08-17 07:56:14 -070036#include <error_messages.hpp>
Ed Tanous45ca1b82022-03-25 13:07:27 -070037#include <query.hpp>
Ed Tanoused398212021-06-09 17:05:54 -070038#include <registries/privilege_registry.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050039
George Liu647b3cd2021-07-05 12:43:56 +080040#include <charconv>
James Feist4418c7f2019-04-15 11:09:15 -070041#include <filesystem>
Xiaochao Ma75710de2021-01-21 17:56:02 +080042#include <optional>
Ed Tanous26702d02021-11-03 15:02:33 -070043#include <span>
Jason M. Billscd225da2019-05-08 15:31:57 -070044#include <string_view>
Ed Tanousabf2add2019-01-22 16:40:12 -080045#include <variant>
Ed Tanous1da66f72018-07-27 16:13:37 -070046
47namespace redfish
48{
49
Gunnar Mills1214b7e2020-06-04 10:11:30 -050050constexpr char const* crashdumpObject = "com.intel.crashdump";
51constexpr char const* crashdumpPath = "/com/intel/crashdump";
Gunnar Mills1214b7e2020-06-04 10:11:30 -050052constexpr char const* crashdumpInterface = "com.intel.crashdump";
53constexpr char const* deleteAllInterface =
Jason M. Bills5b61b5e2019-10-16 10:59:02 -070054 "xyz.openbmc_project.Collection.DeleteAll";
Gunnar Mills1214b7e2020-06-04 10:11:30 -050055constexpr char const* crashdumpOnDemandInterface =
Jason M. Bills424c4172019-03-21 13:50:33 -070056 "com.intel.crashdump.OnDemand";
Kenny L. Ku6eda7682020-06-19 09:48:36 -070057constexpr char const* crashdumpTelemetryInterface =
58 "com.intel.crashdump.Telemetry";
Ed Tanous1da66f72018-07-27 16:13:37 -070059
Ed Tanousfffb8c12022-02-07 23:53:03 -080060namespace registries
Jason M. Bills4851d452019-03-28 11:27:48 -070061{
Ed Tanous26702d02021-11-03 15:02:33 -070062static const Message*
63 getMessageFromRegistry(const std::string& messageKey,
64 const std::span<const MessageEntry> registry)
Jason M. Bills4851d452019-03-28 11:27:48 -070065{
Ed Tanous002d39b2022-05-31 08:59:27 -070066 std::span<const MessageEntry>::iterator messageIt =
67 std::find_if(registry.begin(), registry.end(),
68 [&messageKey](const MessageEntry& messageEntry) {
69 return std::strcmp(messageEntry.first, messageKey.c_str()) == 0;
Ed Tanous26702d02021-11-03 15:02:33 -070070 });
71 if (messageIt != registry.end())
Jason M. Bills4851d452019-03-28 11:27:48 -070072 {
73 return &messageIt->second;
74 }
75
76 return nullptr;
77}
78
Gunnar Mills1214b7e2020-06-04 10:11:30 -050079static const Message* getMessage(const std::string_view& messageID)
Jason M. Bills4851d452019-03-28 11:27:48 -070080{
81 // Redfish MessageIds are in the form
82 // RegistryName.MajorVersion.MinorVersion.MessageKey, so parse it to find
83 // the right Message
84 std::vector<std::string> fields;
85 fields.reserve(4);
86 boost::split(fields, messageID, boost::is_any_of("."));
Gunnar Mills1214b7e2020-06-04 10:11:30 -050087 std::string& registryName = fields[0];
88 std::string& messageKey = fields[3];
Jason M. Bills4851d452019-03-28 11:27:48 -070089
90 // Find the right registry and check it for the MessageKey
91 if (std::string(base::header.registryPrefix) == registryName)
92 {
93 return getMessageFromRegistry(
Ed Tanous26702d02021-11-03 15:02:33 -070094 messageKey, std::span<const MessageEntry>(base::registry));
Jason M. Bills4851d452019-03-28 11:27:48 -070095 }
96 if (std::string(openbmc::header.registryPrefix) == registryName)
97 {
98 return getMessageFromRegistry(
Ed Tanous26702d02021-11-03 15:02:33 -070099 messageKey, std::span<const MessageEntry>(openbmc::registry));
Jason M. Bills4851d452019-03-28 11:27:48 -0700100 }
101 return nullptr;
102}
Ed Tanousfffb8c12022-02-07 23:53:03 -0800103} // namespace registries
Jason M. Bills4851d452019-03-28 11:27:48 -0700104
James Feistf6150402019-01-08 10:36:20 -0800105namespace fs = std::filesystem;
Ed Tanous1da66f72018-07-27 16:13:37 -0700106
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500107inline std::string translateSeverityDbusToRedfish(const std::string& s)
Andrew Geisslercb92c032018-08-17 07:56:14 -0700108{
Ed Tanousd4d25792020-09-29 15:15:03 -0700109 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Alert") ||
110 (s == "xyz.openbmc_project.Logging.Entry.Level.Critical") ||
111 (s == "xyz.openbmc_project.Logging.Entry.Level.Emergency") ||
112 (s == "xyz.openbmc_project.Logging.Entry.Level.Error"))
Andrew Geisslercb92c032018-08-17 07:56:14 -0700113 {
114 return "Critical";
115 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700116 if ((s == "xyz.openbmc_project.Logging.Entry.Level.Debug") ||
117 (s == "xyz.openbmc_project.Logging.Entry.Level.Informational") ||
118 (s == "xyz.openbmc_project.Logging.Entry.Level.Notice"))
Andrew Geisslercb92c032018-08-17 07:56:14 -0700119 {
120 return "OK";
121 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700122 if (s == "xyz.openbmc_project.Logging.Entry.Level.Warning")
Andrew Geisslercb92c032018-08-17 07:56:14 -0700123 {
124 return "Warning";
125 }
126 return "";
127}
128
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700129inline static int getJournalMetadata(sd_journal* journal,
130 const std::string_view& field,
131 std::string_view& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700132{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500133 const char* data = nullptr;
Jason M. Bills16428a12018-11-02 12:42:29 -0700134 size_t length = 0;
135 int ret = 0;
136 // Get the metadata from the requested field of the journal entry
Ed Tanous46ff87b2022-01-07 09:25:51 -0800137 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
138 const void** dataVoid = reinterpret_cast<const void**>(&data);
139
140 ret = sd_journal_get_data(journal, field.data(), dataVoid, &length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700141 if (ret < 0)
142 {
143 return ret;
144 }
Ed Tanous39e77502019-03-04 17:35:53 -0800145 contents = std::string_view(data, length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700146 // Only use the content after the "=" character.
Ed Tanous81ce6092020-12-17 16:54:55 +0000147 contents.remove_prefix(std::min(contents.find('=') + 1, contents.size()));
Jason M. Bills16428a12018-11-02 12:42:29 -0700148 return ret;
149}
150
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700151inline static int getJournalMetadata(sd_journal* journal,
152 const std::string_view& field,
153 const int& base, long int& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700154{
155 int ret = 0;
Ed Tanous39e77502019-03-04 17:35:53 -0800156 std::string_view metadata;
Jason M. Bills16428a12018-11-02 12:42:29 -0700157 // Get the metadata from the requested field of the journal entry
158 ret = getJournalMetadata(journal, field, metadata);
159 if (ret < 0)
160 {
161 return ret;
162 }
Ed Tanousb01bf292019-03-25 19:25:26 +0000163 contents = strtol(metadata.data(), nullptr, base);
Jason M. Bills16428a12018-11-02 12:42:29 -0700164 return ret;
165}
166
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700167inline static bool getEntryTimestamp(sd_journal* journal,
168 std::string& entryTimestamp)
ZhikuiRena3316fc2020-01-29 14:58:08 -0800169{
170 int ret = 0;
171 uint64_t timestamp = 0;
172 ret = sd_journal_get_realtime_usec(journal, &timestamp);
173 if (ret < 0)
174 {
175 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
176 << strerror(-ret);
177 return false;
178 }
Nan Zhou1d8782e2021-11-29 22:23:18 -0800179 entryTimestamp = crow::utility::getDateTimeUint(timestamp / 1000 / 1000);
Asmitha Karunanithi9c620e22020-08-02 11:55:21 -0500180 return true;
ZhikuiRena3316fc2020-01-29 14:58:08 -0800181}
Ed Tanous50b8a432022-02-03 16:29:50 -0800182
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700183inline static bool getUniqueEntryID(sd_journal* journal, std::string& entryID,
184 const bool firstEntry = true)
Jason M. Bills16428a12018-11-02 12:42:29 -0700185{
186 int ret = 0;
187 static uint64_t prevTs = 0;
188 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700189 if (firstEntry)
190 {
191 prevTs = 0;
192 }
193
Jason M. Bills16428a12018-11-02 12:42:29 -0700194 // Get the entry timestamp
195 uint64_t curTs = 0;
196 ret = sd_journal_get_realtime_usec(journal, &curTs);
197 if (ret < 0)
198 {
199 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
200 << strerror(-ret);
201 return false;
202 }
203 // If the timestamp isn't unique, increment the index
204 if (curTs == prevTs)
205 {
206 index++;
207 }
208 else
209 {
210 // Otherwise, reset it
211 index = 0;
212 }
213 // Save the timestamp
214 prevTs = curTs;
215
216 entryID = std::to_string(curTs);
217 if (index > 0)
218 {
219 entryID += "_" + std::to_string(index);
220 }
221 return true;
222}
223
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500224static bool getUniqueEntryID(const std::string& logEntry, std::string& entryID,
Jason M. Billse85d6b12019-07-29 17:01:15 -0700225 const bool firstEntry = true)
Jason M. Bills95820182019-04-22 16:25:34 -0700226{
Ed Tanous271584a2019-07-09 16:24:22 -0700227 static time_t prevTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700228 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700229 if (firstEntry)
230 {
231 prevTs = 0;
232 }
233
Jason M. Bills95820182019-04-22 16:25:34 -0700234 // Get the entry timestamp
Ed Tanous271584a2019-07-09 16:24:22 -0700235 std::time_t curTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700236 std::tm timeStruct = {};
237 std::istringstream entryStream(logEntry);
238 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
239 {
240 curTs = std::mktime(&timeStruct);
241 }
242 // If the timestamp isn't unique, increment the index
243 if (curTs == prevTs)
244 {
245 index++;
246 }
247 else
248 {
249 // Otherwise, reset it
250 index = 0;
251 }
252 // Save the timestamp
253 prevTs = curTs;
254
255 entryID = std::to_string(curTs);
256 if (index > 0)
257 {
258 entryID += "_" + std::to_string(index);
259 }
260 return true;
261}
262
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700263inline static bool
zhanghch058d1b46d2021-04-01 11:18:24 +0800264 getTimestampFromID(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
265 const std::string& entryID, uint64_t& timestamp,
266 uint64_t& index)
Jason M. Bills16428a12018-11-02 12:42:29 -0700267{
268 if (entryID.empty())
269 {
270 return false;
271 }
272 // Convert the unique ID back to a timestamp to find the entry
Ed Tanous39e77502019-03-04 17:35:53 -0800273 std::string_view tsStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700274
Ed Tanous81ce6092020-12-17 16:54:55 +0000275 auto underscorePos = tsStr.find('_');
Ed Tanous71d5d8d2022-01-25 11:04:33 -0800276 if (underscorePos != std::string_view::npos)
Jason M. Bills16428a12018-11-02 12:42:29 -0700277 {
278 // Timestamp has an index
279 tsStr.remove_suffix(tsStr.size() - underscorePos);
Ed Tanous39e77502019-03-04 17:35:53 -0800280 std::string_view indexStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700281 indexStr.remove_prefix(underscorePos + 1);
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700282 auto [ptr, ec] = std::from_chars(
283 indexStr.data(), indexStr.data() + indexStr.size(), index);
284 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700285 {
Ed Tanousace85d62021-10-26 12:45:59 -0700286 messages::resourceMissingAtURI(
287 asyncResp->res, crow::utility::urlFromPieces(entryID));
Jason M. Bills16428a12018-11-02 12:42:29 -0700288 return false;
289 }
290 }
291 // Timestamp has no index
Ed Tanousc0bd5e42021-09-13 17:00:19 -0700292 auto [ptr, ec] =
293 std::from_chars(tsStr.data(), tsStr.data() + tsStr.size(), timestamp);
294 if (ec != std::errc())
Jason M. Bills16428a12018-11-02 12:42:29 -0700295 {
Ed Tanousace85d62021-10-26 12:45:59 -0700296 messages::resourceMissingAtURI(asyncResp->res,
297 crow::utility::urlFromPieces(entryID));
Jason M. Bills16428a12018-11-02 12:42:29 -0700298 return false;
299 }
300 return true;
301}
302
Jason M. Bills95820182019-04-22 16:25:34 -0700303static bool
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500304 getRedfishLogFiles(std::vector<std::filesystem::path>& redfishLogFiles)
Jason M. Bills95820182019-04-22 16:25:34 -0700305{
306 static const std::filesystem::path redfishLogDir = "/var/log";
307 static const std::string redfishLogFilename = "redfish";
308
309 // Loop through the directory looking for redfish log files
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500310 for (const std::filesystem::directory_entry& dirEnt :
Jason M. Bills95820182019-04-22 16:25:34 -0700311 std::filesystem::directory_iterator(redfishLogDir))
312 {
313 // If we find a redfish log file, save the path
314 std::string filename = dirEnt.path().filename();
315 if (boost::starts_with(filename, redfishLogFilename))
316 {
317 redfishLogFiles.emplace_back(redfishLogDir / filename);
318 }
319 }
320 // As the log files rotate, they are appended with a ".#" that is higher for
321 // the older logs. Since we don't expect more than 10 log files, we
322 // can just sort the list to get them in order from newest to oldest
323 std::sort(redfishLogFiles.begin(), redfishLogFiles.end());
324
325 return !redfishLogFiles.empty();
326}
327
Nan Zhou21ab4042022-06-26 23:07:40 +0000328static std::string getDumpEntriesPath(const std::string& dumpType)
Claire Weinanfdd26902022-03-01 14:18:25 -0800329{
330 std::string entriesPath;
331
332 if (dumpType == "BMC")
333 {
334 entriesPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
335 }
336 else if (dumpType == "FaultLog")
337 {
338 entriesPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/";
339 }
340 else if (dumpType == "System")
341 {
342 entriesPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
343 }
344 else
345 {
346 BMCWEB_LOG_ERROR << "getDumpEntriesPath() invalid dump type: "
347 << dumpType;
348 }
349
350 // Returns empty string on error
351 return entriesPath;
352}
353
zhanghch058d1b46d2021-04-01 11:18:24 +0800354inline void
355 getDumpEntryCollection(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
356 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500357{
Claire Weinanfdd26902022-03-01 14:18:25 -0800358 std::string entriesPath = getDumpEntriesPath(dumpType);
359 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500360 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500361 messages::internalError(asyncResp->res);
362 return;
363 }
364
365 crow::connections::systemBus->async_method_call(
Claire Weinanfdd26902022-03-01 14:18:25 -0800366 [asyncResp, entriesPath,
Ed Tanous711ac7a2021-12-20 09:34:41 -0800367 dumpType](const boost::system::error_code ec,
368 dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700369 if (ec)
370 {
371 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
372 messages::internalError(asyncResp->res);
373 return;
374 }
375
Claire Weinanfdd26902022-03-01 14:18:25 -0800376 // Remove ending slash
377 std::string odataIdStr = entriesPath;
378 if (!odataIdStr.empty())
379 {
380 odataIdStr.pop_back();
381 }
382
383 asyncResp->res.jsonValue["@odata.type"] =
384 "#LogEntryCollection.LogEntryCollection";
385 asyncResp->res.jsonValue["@odata.id"] = std::move(odataIdStr);
386 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entries";
387 asyncResp->res.jsonValue["Description"] =
388 "Collection of " + dumpType + " Dump Entries";
389
Ed Tanous002d39b2022-05-31 08:59:27 -0700390 nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
391 entriesArray = nlohmann::json::array();
392 std::string dumpEntryPath =
393 "/xyz/openbmc_project/dump/" +
394 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
395
396 std::sort(resp.begin(), resp.end(), [](const auto& l, const auto& r) {
397 return AlphanumLess<std::string>()(l.first.filename(),
398 r.first.filename());
399 });
400
401 for (auto& object : resp)
402 {
403 if (object.first.str.find(dumpEntryPath) == std::string::npos)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500404 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700405 continue;
406 }
407 uint64_t timestamp = 0;
408 uint64_t size = 0;
409 std::string dumpStatus;
410 nlohmann::json thisEntry;
411
412 std::string entryID = object.first.filename();
413 if (entryID.empty())
414 {
415 continue;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500416 }
417
Ed Tanous002d39b2022-05-31 08:59:27 -0700418 for (auto& interfaceMap : object.second)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500419 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700420 if (interfaceMap.first == "xyz.openbmc_project.Common.Progress")
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500421 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700422 for (const auto& propertyMap : interfaceMap.second)
Asmitha Karunanithi35440d12021-09-07 11:17:57 -0500423 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700424 if (propertyMap.first == "Status")
Asmitha Karunanithi35440d12021-09-07 11:17:57 -0500425 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700426 const auto* status =
427 std::get_if<std::string>(&propertyMap.second);
428 if (status == nullptr)
Asmitha Karunanithi35440d12021-09-07 11:17:57 -0500429 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700430 messages::internalError(asyncResp->res);
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500431 break;
432 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700433 dumpStatus = *status;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500434 }
435 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700436 }
437 else if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
438 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500439
Ed Tanous002d39b2022-05-31 08:59:27 -0700440 for (auto& propertyMap : interfaceMap.second)
441 {
442 if (propertyMap.first == "Size")
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500443 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700444 const auto* sizePtr =
445 std::get_if<uint64_t>(&propertyMap.second);
446 if (sizePtr == nullptr)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500447 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700448 messages::internalError(asyncResp->res);
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500449 break;
450 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700451 size = *sizePtr;
452 break;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500453 }
454 }
455 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700456 else if (interfaceMap.first ==
457 "xyz.openbmc_project.Time.EpochTime")
Asmitha Karunanithi35440d12021-09-07 11:17:57 -0500458 {
Asmitha Karunanithi35440d12021-09-07 11:17:57 -0500459
Ed Tanous002d39b2022-05-31 08:59:27 -0700460 for (const auto& propertyMap : interfaceMap.second)
461 {
462 if (propertyMap.first == "Elapsed")
463 {
464 const uint64_t* usecsTimeStamp =
465 std::get_if<uint64_t>(&propertyMap.second);
466 if (usecsTimeStamp == nullptr)
467 {
468 messages::internalError(asyncResp->res);
469 break;
470 }
471 timestamp = (*usecsTimeStamp / 1000 / 1000);
472 break;
473 }
474 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500475 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500476 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700477
478 if (dumpStatus !=
479 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
480 !dumpStatus.empty())
481 {
482 // Dump status is not Complete, no need to enumerate
483 continue;
484 }
485
486 thisEntry["@odata.type"] = "#LogEntry.v1_8_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800487 thisEntry["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700488 thisEntry["Id"] = entryID;
489 thisEntry["EntryType"] = "Event";
490 thisEntry["Created"] = crow::utility::getDateTimeUint(timestamp);
491 thisEntry["Name"] = dumpType + " Dump Entry";
492
Ed Tanous002d39b2022-05-31 08:59:27 -0700493 if (dumpType == "BMC")
494 {
495 thisEntry["DiagnosticDataType"] = "Manager";
496 thisEntry["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800497 entriesPath + entryID + "/attachment";
498 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700499 }
500 else if (dumpType == "System")
501 {
502 thisEntry["DiagnosticDataType"] = "OEM";
503 thisEntry["OEMDiagnosticDataType"] = "System";
504 thisEntry["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800505 entriesPath + entryID + "/attachment";
506 thisEntry["AdditionalDataSizeBytes"] = size;
Ed Tanous002d39b2022-05-31 08:59:27 -0700507 }
508 entriesArray.push_back(std::move(thisEntry));
509 }
510 asyncResp->res.jsonValue["Members@odata.count"] = entriesArray.size();
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500511 },
512 "xyz.openbmc_project.Dump.Manager", "/xyz/openbmc_project/dump",
513 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
514}
515
zhanghch058d1b46d2021-04-01 11:18:24 +0800516inline void
Claire Weinanc7a6d662022-06-13 16:36:39 -0700517 getDumpEntryById(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
zhanghch058d1b46d2021-04-01 11:18:24 +0800518 const std::string& entryID, const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500519{
Claire Weinanfdd26902022-03-01 14:18:25 -0800520 std::string entriesPath = getDumpEntriesPath(dumpType);
521 if (entriesPath.empty())
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500522 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500523 messages::internalError(asyncResp->res);
524 return;
525 }
526
527 crow::connections::systemBus->async_method_call(
Claire Weinanfdd26902022-03-01 14:18:25 -0800528 [asyncResp, entryID, dumpType,
529 entriesPath](const boost::system::error_code ec,
530 dbus::utility::ManagedObjectType& resp) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700531 if (ec)
532 {
533 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
534 messages::internalError(asyncResp->res);
535 return;
536 }
537
538 bool foundDumpEntry = false;
539 std::string dumpEntryPath =
540 "/xyz/openbmc_project/dump/" +
541 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/";
542
543 for (const auto& objectPath : resp)
544 {
545 if (objectPath.first.str != dumpEntryPath + entryID)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500546 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700547 continue;
548 }
549
550 foundDumpEntry = true;
551 uint64_t timestamp = 0;
552 uint64_t size = 0;
553 std::string dumpStatus;
554
555 for (const auto& interfaceMap : objectPath.second)
556 {
557 if (interfaceMap.first == "xyz.openbmc_project.Common.Progress")
558 {
559 for (const auto& propertyMap : interfaceMap.second)
560 {
561 if (propertyMap.first == "Status")
562 {
563 const std::string* status =
564 std::get_if<std::string>(&propertyMap.second);
565 if (status == nullptr)
566 {
567 messages::internalError(asyncResp->res);
568 break;
569 }
570 dumpStatus = *status;
571 }
572 }
573 }
574 else if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
575 {
576 for (const auto& propertyMap : interfaceMap.second)
577 {
578 if (propertyMap.first == "Size")
579 {
580 const uint64_t* sizePtr =
581 std::get_if<uint64_t>(&propertyMap.second);
582 if (sizePtr == nullptr)
583 {
584 messages::internalError(asyncResp->res);
585 break;
586 }
587 size = *sizePtr;
588 break;
589 }
590 }
591 }
592 else if (interfaceMap.first ==
593 "xyz.openbmc_project.Time.EpochTime")
594 {
595 for (const auto& propertyMap : interfaceMap.second)
596 {
597 if (propertyMap.first == "Elapsed")
598 {
599 const uint64_t* usecsTimeStamp =
600 std::get_if<uint64_t>(&propertyMap.second);
601 if (usecsTimeStamp == nullptr)
602 {
603 messages::internalError(asyncResp->res);
604 break;
605 }
606 timestamp = *usecsTimeStamp / 1000 / 1000;
607 break;
608 }
609 }
610 }
611 }
612
613 if (dumpStatus !=
614 "xyz.openbmc_project.Common.Progress.OperationStatus.Completed" &&
615 !dumpStatus.empty())
616 {
617 // Dump status is not Complete
618 // return not found until status is changed to Completed
619 messages::resourceNotFound(asyncResp->res, dumpType + " dump",
620 entryID);
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500621 return;
622 }
623
Ed Tanous002d39b2022-05-31 08:59:27 -0700624 asyncResp->res.jsonValue["@odata.type"] =
625 "#LogEntry.v1_8_0.LogEntry";
Claire Weinanfdd26902022-03-01 14:18:25 -0800626 asyncResp->res.jsonValue["@odata.id"] = entriesPath + entryID;
Ed Tanous002d39b2022-05-31 08:59:27 -0700627 asyncResp->res.jsonValue["Id"] = entryID;
628 asyncResp->res.jsonValue["EntryType"] = "Event";
629 asyncResp->res.jsonValue["Created"] =
630 crow::utility::getDateTimeUint(timestamp);
631 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entry";
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500632
Ed Tanous002d39b2022-05-31 08:59:27 -0700633 if (dumpType == "BMC")
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500634 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700635 asyncResp->res.jsonValue["DiagnosticDataType"] = "Manager";
636 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800637 entriesPath + entryID + "/attachment";
638 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500639 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700640 else if (dumpType == "System")
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500641 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700642 asyncResp->res.jsonValue["DiagnosticDataType"] = "OEM";
643 asyncResp->res.jsonValue["OEMDiagnosticDataType"] = "System";
644 asyncResp->res.jsonValue["AdditionalDataURI"] =
Claire Weinanfdd26902022-03-01 14:18:25 -0800645 entriesPath + entryID + "/attachment";
646 asyncResp->res.jsonValue["AdditionalDataSizeBytes"] = size;
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500647 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700648 }
649 if (!foundDumpEntry)
650 {
651 BMCWEB_LOG_ERROR << "Can't find Dump Entry";
652 messages::internalError(asyncResp->res);
653 return;
654 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500655 },
656 "xyz.openbmc_project.Dump.Manager", "/xyz/openbmc_project/dump",
657 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
658}
659
zhanghch058d1b46d2021-04-01 11:18:24 +0800660inline void deleteDumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Stanley Chu98782562020-11-04 16:10:24 +0800661 const std::string& entryID,
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500662 const std::string& dumpType)
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500663{
Ed Tanous002d39b2022-05-31 08:59:27 -0700664 auto respHandler =
665 [asyncResp, entryID](const boost::system::error_code ec) {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500666 BMCWEB_LOG_DEBUG << "Dump Entry doDelete callback: Done";
667 if (ec)
668 {
George Liu3de8d8b2021-03-22 17:49:39 +0800669 if (ec.value() == EBADR)
670 {
671 messages::resourceNotFound(asyncResp->res, "LogEntry", entryID);
672 return;
673 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500674 BMCWEB_LOG_ERROR << "Dump (DBus) doDelete respHandler got error "
Claire Weinanfdd26902022-03-01 14:18:25 -0800675 << ec << " entryID=" << entryID;
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500676 messages::internalError(asyncResp->res);
677 return;
678 }
679 };
680 crow::connections::systemBus->async_method_call(
681 respHandler, "xyz.openbmc_project.Dump.Manager",
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500682 "/xyz/openbmc_project/dump/" +
683 std::string(boost::algorithm::to_lower_copy(dumpType)) + "/entry/" +
684 entryID,
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500685 "xyz.openbmc_project.Object.Delete", "Delete");
686}
687
zhanghch058d1b46d2021-04-01 11:18:24 +0800688inline void
Ed Tanous98be3e32021-09-16 15:05:36 -0700689 createDumpTaskCallback(task::Payload&& payload,
zhanghch058d1b46d2021-04-01 11:18:24 +0800690 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
691 const uint32_t& dumpId, const std::string& dumpPath,
692 const std::string& dumpType)
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500693{
694 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
Asmitha Karunanithi6145ed62020-09-17 23:40:03 -0500695 [dumpId, dumpPath, dumpType](
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500696 boost::system::error_code err, sdbusplus::message::message& m,
697 const std::shared_ptr<task::TaskData>& taskData) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700698 if (err)
699 {
700 BMCWEB_LOG_ERROR << "Error in creating a dump";
701 taskData->state = "Cancelled";
Asmitha Karunanithi6145ed62020-09-17 23:40:03 -0500702 return task::completed;
Ed Tanous002d39b2022-05-31 08:59:27 -0700703 }
704
705 dbus::utility::DBusInteracesMap interfacesList;
706
707 sdbusplus::message::object_path objPath;
708
709 m.read(objPath, interfacesList);
710
711 if (objPath.str ==
712 "/xyz/openbmc_project/dump/" +
713 std::string(boost::algorithm::to_lower_copy(dumpType)) +
714 "/entry/" + std::to_string(dumpId))
715 {
716 nlohmann::json retMessage = messages::success();
717 taskData->messages.emplace_back(retMessage);
718
719 std::string headerLoc =
720 "Location: " + dumpPath + std::to_string(dumpId);
721 taskData->payload->httpHeaders.emplace_back(std::move(headerLoc));
722
723 taskData->state = "Completed";
724 return task::completed;
725 }
726 return task::completed;
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500727 },
Jason M. Bills4978b632022-02-22 14:17:43 -0800728 "type='signal',interface='org.freedesktop.DBus.ObjectManager',"
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500729 "member='InterfacesAdded', "
730 "path='/xyz/openbmc_project/dump'");
731
732 task->startTimer(std::chrono::minutes(3));
733 task->populateResp(asyncResp->res);
Ed Tanous98be3e32021-09-16 15:05:36 -0700734 task->payload.emplace(std::move(payload));
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500735}
736
zhanghch058d1b46d2021-04-01 11:18:24 +0800737inline void createDump(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
738 const crow::Request& req, const std::string& dumpType)
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500739{
Claire Weinanfdd26902022-03-01 14:18:25 -0800740 std::string dumpPath = getDumpEntriesPath(dumpType);
741 if (dumpPath.empty())
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500742 {
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500743 messages::internalError(asyncResp->res);
744 return;
745 }
746
747 std::optional<std::string> diagnosticDataType;
748 std::optional<std::string> oemDiagnosticDataType;
749
Willy Tu15ed6782021-12-14 11:03:16 -0800750 if (!redfish::json_util::readJsonAction(
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500751 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
752 "OEMDiagnosticDataType", oemDiagnosticDataType))
753 {
754 return;
755 }
756
757 if (dumpType == "System")
758 {
759 if (!oemDiagnosticDataType || !diagnosticDataType)
760 {
Jason M. Bills4978b632022-02-22 14:17:43 -0800761 BMCWEB_LOG_ERROR
762 << "CreateDump action parameter 'DiagnosticDataType'/'OEMDiagnosticDataType' value not found!";
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500763 messages::actionParameterMissing(
764 asyncResp->res, "CollectDiagnosticData",
765 "DiagnosticDataType & OEMDiagnosticDataType");
766 return;
767 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700768 if ((*oemDiagnosticDataType != "System") ||
769 (*diagnosticDataType != "OEM"))
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500770 {
771 BMCWEB_LOG_ERROR << "Wrong parameter values passed";
Ed Tanousace85d62021-10-26 12:45:59 -0700772 messages::internalError(asyncResp->res);
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500773 return;
774 }
775 }
776 else if (dumpType == "BMC")
777 {
778 if (!diagnosticDataType)
779 {
George Liu0fda0f12021-11-16 10:06:17 +0800780 BMCWEB_LOG_ERROR
781 << "CreateDump action parameter 'DiagnosticDataType' not found!";
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500782 messages::actionParameterMissing(
783 asyncResp->res, "CollectDiagnosticData", "DiagnosticDataType");
784 return;
785 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700786 if (*diagnosticDataType != "Manager")
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500787 {
788 BMCWEB_LOG_ERROR
789 << "Wrong parameter value passed for 'DiagnosticDataType'";
Ed Tanousace85d62021-10-26 12:45:59 -0700790 messages::internalError(asyncResp->res);
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500791 return;
792 }
793 }
794
795 crow::connections::systemBus->async_method_call(
Ed Tanous98be3e32021-09-16 15:05:36 -0700796 [asyncResp, payload(task::Payload(req)), dumpPath,
797 dumpType](const boost::system::error_code ec,
798 const uint32_t& dumpId) mutable {
Ed Tanous002d39b2022-05-31 08:59:27 -0700799 if (ec)
800 {
801 BMCWEB_LOG_ERROR << "CreateDump resp_handler got error " << ec;
802 messages::internalError(asyncResp->res);
803 return;
804 }
805 BMCWEB_LOG_DEBUG << "Dump Created. Id: " << dumpId;
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500806
Ed Tanous002d39b2022-05-31 08:59:27 -0700807 createDumpTaskCallback(std::move(payload), asyncResp, dumpId, dumpPath,
808 dumpType);
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500809 },
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500810 "xyz.openbmc_project.Dump.Manager",
811 "/xyz/openbmc_project/dump/" +
812 std::string(boost::algorithm::to_lower_copy(dumpType)),
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500813 "xyz.openbmc_project.Dump.Create", "CreateDump");
814}
815
zhanghch058d1b46d2021-04-01 11:18:24 +0800816inline void clearDump(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
817 const std::string& dumpType)
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500818{
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500819 std::string dumpTypeLowerCopy =
820 std::string(boost::algorithm::to_lower_copy(dumpType));
zhanghch058d1b46d2021-04-01 11:18:24 +0800821
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500822 crow::connections::systemBus->async_method_call(
Ed Tanousb9d36b42022-02-26 21:42:46 -0800823 [asyncResp, dumpType](
824 const boost::system::error_code ec,
825 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700826 if (ec)
827 {
828 BMCWEB_LOG_ERROR << "resp_handler got error " << ec;
829 messages::internalError(asyncResp->res);
830 return;
831 }
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500832
Ed Tanous002d39b2022-05-31 08:59:27 -0700833 for (const std::string& path : subTreePaths)
834 {
835 sdbusplus::message::object_path objPath(path);
836 std::string logID = objPath.filename();
837 if (logID.empty())
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500838 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700839 continue;
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500840 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700841 deleteDumpEntry(asyncResp, logID, dumpType);
842 }
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500843 },
844 "xyz.openbmc_project.ObjectMapper",
845 "/xyz/openbmc_project/object_mapper",
846 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
Asmitha Karunanithib47452b2020-09-25 02:02:19 -0500847 "/xyz/openbmc_project/dump/" + dumpTypeLowerCopy, 0,
848 std::array<std::string, 1>{"xyz.openbmc_project.Dump.Entry." +
849 dumpType});
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500850}
851
Ed Tanousb9d36b42022-02-26 21:42:46 -0800852inline static void
853 parseCrashdumpParameters(const dbus::utility::DBusPropertiesMap& params,
854 std::string& filename, std::string& timestamp,
855 std::string& logfile)
Johnathan Mantey043a0532020-03-10 17:15:28 -0700856{
857 for (auto property : params)
858 {
859 if (property.first == "Timestamp")
860 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500861 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500862 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700863 if (value != nullptr)
864 {
865 timestamp = *value;
866 }
867 }
868 else if (property.first == "Filename")
869 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500870 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500871 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700872 if (value != nullptr)
873 {
874 filename = *value;
875 }
876 }
877 else if (property.first == "Log")
878 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500879 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500880 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700881 if (value != nullptr)
882 {
883 logfile = *value;
884 }
885 }
886 }
887}
888
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500889constexpr char const* postCodeIface = "xyz.openbmc_project.State.Boot.PostCode";
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700890inline void requestRoutesSystemLogServiceCollection(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -0700891{
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800892 /**
893 * Functions triggers appropriate requests on DBus
894 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700895 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/")
Ed Tanoused398212021-06-09 17:05:54 -0700896 .privileges(redfish::privileges::getLogServiceCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -0700897 .methods(boost::beast::http::verb::get)(
898 [&app](const crow::Request& req,
899 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +0000900 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -0700901 {
902 return;
903 }
904 // Collections don't include the static data added by SubRoute
905 // because it has a duplicate entry for members
906 asyncResp->res.jsonValue["@odata.type"] =
907 "#LogServiceCollection.LogServiceCollection";
908 asyncResp->res.jsonValue["@odata.id"] =
909 "/redfish/v1/Systems/system/LogServices";
910 asyncResp->res.jsonValue["Name"] = "System Log Services Collection";
911 asyncResp->res.jsonValue["Description"] =
912 "Collection of LogServices for this Computer System";
913 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
914 logServiceArray = nlohmann::json::array();
915 nlohmann::json::object_t eventLog;
916 eventLog["@odata.id"] =
917 "/redfish/v1/Systems/system/LogServices/EventLog";
918 logServiceArray.push_back(std::move(eventLog));
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500919#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -0700920 nlohmann::json::object_t dumpLog;
921 dumpLog["@odata.id"] = "/redfish/v1/Systems/system/LogServices/Dump";
922 logServiceArray.push_back(std::move(dumpLog));
raviteja-bc9bb6862020-02-03 11:53:32 -0600923#endif
924
Jason M. Billsd53dd412019-02-12 17:16:22 -0800925#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
Ed Tanous002d39b2022-05-31 08:59:27 -0700926 nlohmann::json::object_t crashdump;
927 crashdump["@odata.id"] =
928 "/redfish/v1/Systems/system/LogServices/Crashdump";
929 logServiceArray.push_back(std::move(crashdump));
Jason M. Billsd53dd412019-02-12 17:16:22 -0800930#endif
Spencer Kub7028eb2021-10-26 15:27:35 +0800931
932#ifdef BMCWEB_ENABLE_REDFISH_HOST_LOGGER
Ed Tanous002d39b2022-05-31 08:59:27 -0700933 nlohmann::json::object_t hostlogger;
934 hostlogger["@odata.id"] =
935 "/redfish/v1/Systems/system/LogServices/HostLogger";
936 logServiceArray.push_back(std::move(hostlogger));
Spencer Kub7028eb2021-10-26 15:27:35 +0800937#endif
Ed Tanous002d39b2022-05-31 08:59:27 -0700938 asyncResp->res.jsonValue["Members@odata.count"] =
939 logServiceArray.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -0800940
Ed Tanous002d39b2022-05-31 08:59:27 -0700941 crow::connections::systemBus->async_method_call(
942 [asyncResp](const boost::system::error_code ec,
943 const dbus::utility::MapperGetSubTreePathsResponse&
944 subtreePath) {
945 if (ec)
946 {
947 BMCWEB_LOG_ERROR << ec;
948 return;
949 }
Ed Tanous45ca1b82022-03-25 13:07:27 -0700950
Ed Tanous002d39b2022-05-31 08:59:27 -0700951 for (const auto& pathStr : subtreePath)
952 {
953 if (pathStr.find("PostCode") != std::string::npos)
954 {
955 nlohmann::json& logServiceArrayLocal =
956 asyncResp->res.jsonValue["Members"];
957 logServiceArrayLocal.push_back(
958 {{"@odata.id",
959 "/redfish/v1/Systems/system/LogServices/PostCodes"}});
960 asyncResp->res.jsonValue["Members@odata.count"] =
961 logServiceArrayLocal.size();
962 return;
963 }
964 }
965 },
966 "xyz.openbmc_project.ObjectMapper",
967 "/xyz/openbmc_project/object_mapper",
968 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/", 0,
969 std::array<const char*, 1>{postCodeIface});
Ed Tanous45ca1b82022-03-25 13:07:27 -0700970 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -0700971}
972
973inline void requestRoutesEventLogService(App& app)
974{
975 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/EventLog/")
Ed Tanoused398212021-06-09 17:05:54 -0700976 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -0700977 .methods(boost::beast::http::verb::get)(
978 [&app](const crow::Request& req,
979 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +0000980 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -0700981 {
982 return;
983 }
984 asyncResp->res.jsonValue["@odata.id"] =
985 "/redfish/v1/Systems/system/LogServices/EventLog";
986 asyncResp->res.jsonValue["@odata.type"] =
987 "#LogService.v1_1_0.LogService";
988 asyncResp->res.jsonValue["Name"] = "Event Log Service";
989 asyncResp->res.jsonValue["Description"] = "System Event Log Service";
990 asyncResp->res.jsonValue["Id"] = "EventLog";
991 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +0530992
Ed Tanous002d39b2022-05-31 08:59:27 -0700993 std::pair<std::string, std::string> redfishDateTimeOffset =
994 crow::utility::getDateTimeOffsetNow();
Tejas Patil7c8c4052021-06-04 17:43:14 +0530995
Ed Tanous002d39b2022-05-31 08:59:27 -0700996 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
997 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
998 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +0530999
Ed Tanous002d39b2022-05-31 08:59:27 -07001000 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
1001 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1002 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001003
Ed Tanous002d39b2022-05-31 08:59:27 -07001004 {"target",
1005 "/redfish/v1/Systems/system/LogServices/EventLog/Actions/LogService.ClearLog"}};
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001006 });
1007}
1008
1009inline void requestRoutesJournalEventLogClear(App& app)
1010{
Jason M. Bills4978b632022-02-22 14:17:43 -08001011 BMCWEB_ROUTE(
1012 app,
1013 "/redfish/v1/Systems/system/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanous432a8902021-06-14 15:28:56 -07001014 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001015 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001016 [&app](const crow::Request& req,
1017 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001018 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001019 {
1020 return;
1021 }
1022 // Clear the EventLog by deleting the log files
1023 std::vector<std::filesystem::path> redfishLogFiles;
1024 if (getRedfishLogFiles(redfishLogFiles))
1025 {
1026 for (const std::filesystem::path& file : redfishLogFiles)
1027 {
1028 std::error_code ec;
1029 std::filesystem::remove(file, ec);
1030 }
1031 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001032
Ed Tanous002d39b2022-05-31 08:59:27 -07001033 // Reload rsyslog so it knows to start new log files
1034 crow::connections::systemBus->async_method_call(
1035 [asyncResp](const boost::system::error_code ec) {
1036 if (ec)
1037 {
1038 BMCWEB_LOG_ERROR << "Failed to reload rsyslog: " << ec;
1039 messages::internalError(asyncResp->res);
1040 return;
1041 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001042
Ed Tanous002d39b2022-05-31 08:59:27 -07001043 messages::success(asyncResp->res);
1044 },
1045 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1046 "org.freedesktop.systemd1.Manager", "ReloadUnit", "rsyslog.service",
1047 "replace");
1048 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001049}
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001050
Jason M. Billsac992cd2022-06-24 13:31:46 -07001051enum class LogParseError
1052{
1053 success,
1054 parseFailed,
1055 messageIdNotInRegistry,
1056};
1057
1058static LogParseError
1059 fillEventLogEntryJson(const std::string& logEntryID,
1060 const std::string& logEntry,
1061 nlohmann::json::object_t& logEntryJson)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001062{
Jason M. Bills95820182019-04-22 16:25:34 -07001063 // The redfish log format is "<Timestamp> <MessageId>,<MessageArgs>"
Jason M. Billscd225da2019-05-08 15:31:57 -07001064 // First get the Timestamp
Ed Tanousf23b7292020-10-15 09:41:17 -07001065 size_t space = logEntry.find_first_of(' ');
Jason M. Billscd225da2019-05-08 15:31:57 -07001066 if (space == std::string::npos)
Jason M. Bills95820182019-04-22 16:25:34 -07001067 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001068 return LogParseError::parseFailed;
Jason M. Bills95820182019-04-22 16:25:34 -07001069 }
Jason M. Billscd225da2019-05-08 15:31:57 -07001070 std::string timestamp = logEntry.substr(0, space);
1071 // Then get the log contents
Ed Tanousf23b7292020-10-15 09:41:17 -07001072 size_t entryStart = logEntry.find_first_not_of(' ', space);
Jason M. Billscd225da2019-05-08 15:31:57 -07001073 if (entryStart == std::string::npos)
1074 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001075 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001076 }
1077 std::string_view entry(logEntry);
1078 entry.remove_prefix(entryStart);
1079 // Use split to separate the entry into its fields
1080 std::vector<std::string> logEntryFields;
1081 boost::split(logEntryFields, entry, boost::is_any_of(","),
1082 boost::token_compress_on);
1083 // We need at least a MessageId to be valid
Ed Tanous26f69762022-01-25 09:49:11 -08001084 if (logEntryFields.empty())
Jason M. Billscd225da2019-05-08 15:31:57 -07001085 {
Jason M. Billsac992cd2022-06-24 13:31:46 -07001086 return LogParseError::parseFailed;
Jason M. Billscd225da2019-05-08 15:31:57 -07001087 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001088 std::string& messageID = logEntryFields[0];
Jason M. Bills95820182019-04-22 16:25:34 -07001089
Jason M. Bills4851d452019-03-28 11:27:48 -07001090 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08001091 const registries::Message* message = registries::getMessage(messageID);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001092
Sui Chen54417b02022-03-24 14:59:52 -07001093 if (message == nullptr)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001094 {
Sui Chen54417b02022-03-24 14:59:52 -07001095 BMCWEB_LOG_WARNING << "Log entry not found in registry: " << logEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001096 return LogParseError::messageIdNotInRegistry;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001097 }
1098
Sui Chen54417b02022-03-24 14:59:52 -07001099 std::string msg = message->message;
1100
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001101 // Get the MessageArgs from the log if there are any
Ed Tanous26702d02021-11-03 15:02:33 -07001102 std::span<std::string> messageArgs;
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001103 if (logEntryFields.size() > 1)
Jason M. Bills4851d452019-03-28 11:27:48 -07001104 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001105 std::string& messageArgsStart = logEntryFields[1];
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001106 // If the first string is empty, assume there are no MessageArgs
1107 std::size_t messageArgsSize = 0;
1108 if (!messageArgsStart.empty())
Jason M. Bills4851d452019-03-28 11:27:48 -07001109 {
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001110 messageArgsSize = logEntryFields.size() - 1;
1111 }
1112
Ed Tanous23a21a12020-07-25 04:45:05 +00001113 messageArgs = {&messageArgsStart, messageArgsSize};
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001114
1115 // Fill the MessageArgs into the Message
1116 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001117 for (const std::string& messageArg : messageArgs)
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001118 {
1119 std::string argStr = "%" + std::to_string(++i);
1120 size_t argPos = msg.find(argStr);
1121 if (argPos != std::string::npos)
1122 {
1123 msg.replace(argPos, argStr.length(), messageArg);
1124 }
Jason M. Bills4851d452019-03-28 11:27:48 -07001125 }
1126 }
1127
Jason M. Bills95820182019-04-22 16:25:34 -07001128 // Get the Created time from the timestamp. The log timestamp is in RFC3339
1129 // format which matches the Redfish format except for the fractional seconds
1130 // between the '.' and the '+', so just remove them.
Ed Tanousf23b7292020-10-15 09:41:17 -07001131 std::size_t dot = timestamp.find_first_of('.');
1132 std::size_t plus = timestamp.find_first_of('+');
Jason M. Bills95820182019-04-22 16:25:34 -07001133 if (dot != std::string::npos && plus != std::string::npos)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001134 {
Jason M. Bills95820182019-04-22 16:25:34 -07001135 timestamp.erase(dot, plus - dot);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001136 }
1137
1138 // Fill in the log entry with the gathered data
Jason M. Bills84afc482022-06-24 12:38:23 -07001139 logEntryJson["@odata.type"] = "#LogEntry.v1_8_0.LogEntry";
1140 logEntryJson["@odata.id"] =
1141 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" + logEntryID;
1142 logEntryJson["Name"] = "System Event Log Entry";
1143 logEntryJson["Id"] = logEntryID;
1144 logEntryJson["Message"] = std::move(msg);
1145 logEntryJson["MessageId"] = std::move(messageID);
1146 logEntryJson["MessageArgs"] = messageArgs;
1147 logEntryJson["EntryType"] = "Event";
1148 logEntryJson["Severity"] = message->messageSeverity;
1149 logEntryJson["Created"] = std::move(timestamp);
Jason M. Billsac992cd2022-06-24 13:31:46 -07001150 return LogParseError::success;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001151}
1152
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001153inline void requestRoutesJournalEventLogEntryCollection(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001154{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001155 BMCWEB_ROUTE(app,
1156 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
Gunnar Mills8b6a35f2021-07-30 14:52:53 -05001157 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001158 .methods(boost::beast::http::verb::get)(
1159 [&app](const crow::Request& req,
1160 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
1161 query_param::QueryCapabilities capabilities = {
1162 .canDelegateTop = true,
1163 .canDelegateSkip = true,
1164 };
1165 query_param::Query delegatedQuery;
1166 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00001167 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07001168 {
1169 return;
1170 }
1171 // Collections don't include the static data added by SubRoute
1172 // because it has a duplicate entry for members
1173 asyncResp->res.jsonValue["@odata.type"] =
1174 "#LogEntryCollection.LogEntryCollection";
1175 asyncResp->res.jsonValue["@odata.id"] =
1176 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1177 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1178 asyncResp->res.jsonValue["Description"] =
1179 "Collection of System Event Log Entries";
1180
1181 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
1182 logEntryArray = nlohmann::json::array();
1183 // Go through the log files and create a unique ID for each
1184 // entry
1185 std::vector<std::filesystem::path> redfishLogFiles;
1186 getRedfishLogFiles(redfishLogFiles);
1187 uint64_t entryCount = 0;
1188 std::string logEntry;
1189
1190 // Oldest logs are in the last file, so start there and loop
1191 // backwards
1192 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1193 it++)
1194 {
1195 std::ifstream logStream(*it);
1196 if (!logStream.is_open())
Jason M. Bills4978b632022-02-22 14:17:43 -08001197 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001198 continue;
Jason M. Bills4978b632022-02-22 14:17:43 -08001199 }
Jason M. Bills897967d2019-07-29 17:05:30 -07001200
Ed Tanous002d39b2022-05-31 08:59:27 -07001201 // Reset the unique ID on the first entry
1202 bool firstEntry = true;
1203 while (std::getline(logStream, logEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001204 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001205 std::string idStr;
1206 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Jason M. Bills4978b632022-02-22 14:17:43 -08001207 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001208 continue;
1209 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001210 firstEntry = false;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001211
Jason M. Billsde703c52022-06-23 14:19:04 -07001212 nlohmann::json::object_t bmcLogEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001213 LogParseError status =
1214 fillEventLogEntryJson(idStr, logEntry, bmcLogEntry);
1215 if (status == LogParseError::messageIdNotInRegistry)
1216 {
1217 continue;
1218 }
1219 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001220 {
1221 messages::internalError(asyncResp->res);
1222 return;
Andrew Geisslercb92c032018-08-17 07:56:14 -07001223 }
Jason M. Billsde703c52022-06-23 14:19:04 -07001224
Jason M. Billsde703c52022-06-23 14:19:04 -07001225 entryCount++;
1226 // Handle paging using skip (number of entries to skip from the
1227 // start) and top (number of entries to display)
1228 if (entryCount <= delegatedQuery.skip ||
1229 entryCount > delegatedQuery.skip + delegatedQuery.top)
1230 {
1231 continue;
1232 }
1233
1234 logEntryArray.push_back(std::move(bmcLogEntry));
Jason M. Bills4978b632022-02-22 14:17:43 -08001235 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001236 }
1237 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
1238 if (delegatedQuery.skip + delegatedQuery.top < entryCount)
1239 {
1240 asyncResp->res.jsonValue["Members@odata.nextLink"] =
1241 "/redfish/v1/Systems/system/LogServices/EventLog/Entries?$skip=" +
1242 std::to_string(delegatedQuery.skip + delegatedQuery.top);
1243 }
Jason M. Bills4978b632022-02-22 14:17:43 -08001244 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001245}
Chicago Duan336e96c2019-07-15 14:22:08 +08001246
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001247inline void requestRoutesJournalEventLogEntry(App& app)
1248{
1249 BMCWEB_ROUTE(
1250 app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001251 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001252 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001253 [&app](const crow::Request& req,
1254 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1255 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001256 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001257 {
1258 return;
1259 }
1260 const std::string& targetID = param;
1261
1262 // Go through the log files and check the unique ID for each
1263 // entry to find the target entry
1264 std::vector<std::filesystem::path> redfishLogFiles;
1265 getRedfishLogFiles(redfishLogFiles);
1266 std::string logEntry;
1267
1268 // Oldest logs are in the last file, so start there and loop
1269 // backwards
1270 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1271 it++)
1272 {
1273 std::ifstream logStream(*it);
1274 if (!logStream.is_open())
1275 {
1276 continue;
1277 }
1278
1279 // Reset the unique ID on the first entry
1280 bool firstEntry = true;
1281 while (std::getline(logStream, logEntry))
1282 {
1283 std::string idStr;
1284 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Ed Tanous45ca1b82022-03-25 13:07:27 -07001285 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001286 continue;
1287 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07001288 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07001289
1290 if (idStr == targetID)
1291 {
Jason M. Billsde703c52022-06-23 14:19:04 -07001292 nlohmann::json::object_t bmcLogEntry;
Jason M. Billsac992cd2022-06-24 13:31:46 -07001293 LogParseError status =
1294 fillEventLogEntryJson(idStr, logEntry, bmcLogEntry);
1295 if (status != LogParseError::success)
Ed Tanous002d39b2022-05-31 08:59:27 -07001296 {
1297 messages::internalError(asyncResp->res);
1298 return;
1299 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07001300 asyncResp->res.jsonValue.update(bmcLogEntry);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001301 return;
1302 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001303 }
1304 }
1305 // Requested ID was not found
1306 messages::resourceMissingAtURI(asyncResp->res,
1307 crow::utility::urlFromPieces(targetID));
1308 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001309}
1310
1311inline void requestRoutesDBusEventLogEntryCollection(App& app)
1312{
1313 BMCWEB_ROUTE(app,
1314 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07001315 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001316 .methods(boost::beast::http::verb::get)(
1317 [&app](const crow::Request& req,
1318 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001319 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001320 {
1321 return;
1322 }
1323 // Collections don't include the static data added by SubRoute
1324 // because it has a duplicate entry for members
1325 asyncResp->res.jsonValue["@odata.type"] =
1326 "#LogEntryCollection.LogEntryCollection";
1327 asyncResp->res.jsonValue["@odata.id"] =
1328 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1329 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1330 asyncResp->res.jsonValue["Description"] =
1331 "Collection of System Event Log Entries";
1332
1333 // DBus implementation of EventLog/Entries
1334 // Make call to Logging Service to find all log entry objects
1335 crow::connections::systemBus->async_method_call(
1336 [asyncResp](const boost::system::error_code ec,
1337 const dbus::utility::ManagedObjectType& resp) {
1338 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001339 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001340 // TODO Handle for specific error code
1341 BMCWEB_LOG_ERROR
1342 << "getLogEntriesIfaceData resp_handler got error " << ec;
1343 messages::internalError(asyncResp->res);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001344 return;
1345 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001346 nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
1347 entriesArray = nlohmann::json::array();
1348 for (const auto& objectPath : resp)
1349 {
1350 const uint32_t* id = nullptr;
1351 const uint64_t* timestamp = nullptr;
1352 const uint64_t* updateTimestamp = nullptr;
1353 const std::string* severity = nullptr;
1354 const std::string* message = nullptr;
1355 const std::string* filePath = nullptr;
1356 bool resolved = false;
1357 for (const auto& interfaceMap : objectPath.second)
1358 {
1359 if (interfaceMap.first ==
1360 "xyz.openbmc_project.Logging.Entry")
Xiaochao Ma75710de2021-01-21 17:56:02 +08001361 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001362 for (const auto& propertyMap : interfaceMap.second)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001363 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001364 if (propertyMap.first == "Id")
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001365 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001366 id = std::get_if<uint32_t>(&propertyMap.second);
1367 }
1368 else if (propertyMap.first == "Timestamp")
1369 {
1370 timestamp =
1371 std::get_if<uint64_t>(&propertyMap.second);
1372 }
1373 else if (propertyMap.first == "UpdateTimestamp")
1374 {
1375 updateTimestamp =
1376 std::get_if<uint64_t>(&propertyMap.second);
1377 }
1378 else if (propertyMap.first == "Severity")
1379 {
1380 severity = std::get_if<std::string>(
1381 &propertyMap.second);
1382 }
1383 else if (propertyMap.first == "Message")
1384 {
1385 message = std::get_if<std::string>(
1386 &propertyMap.second);
1387 }
1388 else if (propertyMap.first == "Resolved")
1389 {
1390 const bool* resolveptr =
1391 std::get_if<bool>(&propertyMap.second);
1392 if (resolveptr == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001393 {
1394 messages::internalError(asyncResp->res);
1395 return;
1396 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001397 resolved = *resolveptr;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001398 }
1399 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001400 if (id == nullptr || message == nullptr ||
Ed Tanous002d39b2022-05-31 08:59:27 -07001401 severity == nullptr)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001402 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001403 messages::internalError(asyncResp->res);
1404 return;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001405 }
1406 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001407 else if (interfaceMap.first ==
1408 "xyz.openbmc_project.Common.FilePath")
1409 {
1410 for (const auto& propertyMap : interfaceMap.second)
1411 {
1412 if (propertyMap.first == "Path")
1413 {
1414 filePath = std::get_if<std::string>(
1415 &propertyMap.second);
1416 }
1417 }
1418 }
1419 }
1420 // Object path without the
1421 // xyz.openbmc_project.Logging.Entry interface, ignore
1422 // and continue.
1423 if (id == nullptr || message == nullptr ||
1424 severity == nullptr || timestamp == nullptr ||
1425 updateTimestamp == nullptr)
1426 {
1427 continue;
1428 }
1429 entriesArray.push_back({});
1430 nlohmann::json& thisEntry = entriesArray.back();
1431 thisEntry["@odata.type"] = "#LogEntry.v1_8_0.LogEntry";
1432 thisEntry["@odata.id"] =
1433 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1434 std::to_string(*id);
1435 thisEntry["Name"] = "System Event Log Entry";
1436 thisEntry["Id"] = std::to_string(*id);
1437 thisEntry["Message"] = *message;
1438 thisEntry["Resolved"] = resolved;
1439 thisEntry["EntryType"] = "Event";
1440 thisEntry["Severity"] =
1441 translateSeverityDbusToRedfish(*severity);
1442 thisEntry["Created"] =
1443 crow::utility::getDateTimeUintMs(*timestamp);
1444 thisEntry["Modified"] =
1445 crow::utility::getDateTimeUintMs(*updateTimestamp);
1446 if (filePath != nullptr)
1447 {
1448 thisEntry["AdditionalDataURI"] =
1449 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1450 std::to_string(*id) + "/attachment";
1451 }
1452 }
1453 std::sort(
1454 entriesArray.begin(), entriesArray.end(),
1455 [](const nlohmann::json& left, const nlohmann::json& right) {
1456 return (left["Id"] <= right["Id"]);
1457 });
1458 asyncResp->res.jsonValue["Members@odata.count"] =
1459 entriesArray.size();
1460 },
1461 "xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
1462 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001463 });
1464}
Xiaochao Ma75710de2021-01-21 17:56:02 +08001465
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001466inline void requestRoutesDBusEventLogEntry(App& app)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001467{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001468 BMCWEB_ROUTE(
1469 app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001470 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07001471 .methods(boost::beast::http::verb::get)(
1472 [&app](const crow::Request& req,
1473 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1474 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001475 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001476 {
1477 return;
1478 }
1479 std::string entryID = param;
1480 dbus::utility::escapePathForDbus(entryID);
1481
1482 // DBus implementation of EventLog/Entries
1483 // Make call to Logging Service to find all log entry objects
1484 crow::connections::systemBus->async_method_call(
1485 [asyncResp, entryID](const boost::system::error_code ec,
1486 const dbus::utility::DBusPropertiesMap& resp) {
1487 if (ec.value() == EBADR)
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001488 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001489 messages::resourceNotFound(asyncResp->res, "EventLogEntry",
1490 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001491 return;
1492 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001493 if (ec)
1494 {
1495 BMCWEB_LOG_ERROR
1496 << "EventLogEntry (DBus) resp_handler got error " << ec;
1497 messages::internalError(asyncResp->res);
1498 return;
1499 }
1500 const uint32_t* id = nullptr;
1501 const uint64_t* timestamp = nullptr;
1502 const uint64_t* updateTimestamp = nullptr;
1503 const std::string* severity = nullptr;
1504 const std::string* message = nullptr;
1505 const std::string* filePath = nullptr;
1506 bool resolved = false;
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001507
Ed Tanous002d39b2022-05-31 08:59:27 -07001508 for (const auto& propertyMap : resp)
1509 {
1510 if (propertyMap.first == "Id")
1511 {
1512 id = std::get_if<uint32_t>(&propertyMap.second);
1513 }
1514 else if (propertyMap.first == "Timestamp")
1515 {
1516 timestamp = std::get_if<uint64_t>(&propertyMap.second);
1517 }
1518 else if (propertyMap.first == "UpdateTimestamp")
1519 {
1520 updateTimestamp =
1521 std::get_if<uint64_t>(&propertyMap.second);
1522 }
1523 else if (propertyMap.first == "Severity")
1524 {
1525 severity = std::get_if<std::string>(&propertyMap.second);
1526 }
1527 else if (propertyMap.first == "Message")
1528 {
1529 message = std::get_if<std::string>(&propertyMap.second);
1530 }
1531 else if (propertyMap.first == "Resolved")
1532 {
1533 const bool* resolveptr =
1534 std::get_if<bool>(&propertyMap.second);
1535 if (resolveptr == nullptr)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001536 {
1537 messages::internalError(asyncResp->res);
1538 return;
1539 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001540 resolved = *resolveptr;
1541 }
1542 else if (propertyMap.first == "Path")
1543 {
1544 filePath = std::get_if<std::string>(&propertyMap.second);
1545 }
1546 }
1547 if (id == nullptr || message == nullptr || severity == nullptr ||
1548 timestamp == nullptr || updateTimestamp == nullptr)
1549 {
1550 messages::internalError(asyncResp->res);
1551 return;
1552 }
1553 asyncResp->res.jsonValue["@odata.type"] =
1554 "#LogEntry.v1_8_0.LogEntry";
1555 asyncResp->res.jsonValue["@odata.id"] =
1556 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1557 std::to_string(*id);
1558 asyncResp->res.jsonValue["Name"] = "System Event Log Entry";
1559 asyncResp->res.jsonValue["Id"] = std::to_string(*id);
1560 asyncResp->res.jsonValue["Message"] = *message;
1561 asyncResp->res.jsonValue["Resolved"] = resolved;
1562 asyncResp->res.jsonValue["EntryType"] = "Event";
1563 asyncResp->res.jsonValue["Severity"] =
1564 translateSeverityDbusToRedfish(*severity);
1565 asyncResp->res.jsonValue["Created"] =
1566 crow::utility::getDateTimeUintMs(*timestamp);
1567 asyncResp->res.jsonValue["Modified"] =
1568 crow::utility::getDateTimeUintMs(*updateTimestamp);
1569 if (filePath != nullptr)
1570 {
1571 asyncResp->res.jsonValue["AdditionalDataURI"] =
1572 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
1573 std::to_string(*id) + "/attachment";
1574 }
1575 },
1576 "xyz.openbmc_project.Logging",
1577 "/xyz/openbmc_project/logging/entry/" + entryID,
1578 "org.freedesktop.DBus.Properties", "GetAll", "");
Ed Tanous45ca1b82022-03-25 13:07:27 -07001579 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001580
1581 BMCWEB_ROUTE(
1582 app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001583 .privileges(redfish::privileges::patchLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001584 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001585 [&app](const crow::Request& req,
1586 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1587 const std::string& entryId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001588 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001589 {
1590 return;
1591 }
1592 std::optional<bool> resolved;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001593
Ed Tanous002d39b2022-05-31 08:59:27 -07001594 if (!json_util::readJsonPatch(req, asyncResp->res, "Resolved",
1595 resolved))
1596 {
1597 return;
1598 }
1599 BMCWEB_LOG_DEBUG << "Set Resolved";
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001600
Ed Tanous002d39b2022-05-31 08:59:27 -07001601 crow::connections::systemBus->async_method_call(
1602 [asyncResp, entryId](const boost::system::error_code ec) {
1603 if (ec)
1604 {
1605 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1606 messages::internalError(asyncResp->res);
1607 return;
1608 }
1609 },
1610 "xyz.openbmc_project.Logging",
1611 "/xyz/openbmc_project/logging/entry/" + entryId,
1612 "org.freedesktop.DBus.Properties", "Set",
1613 "xyz.openbmc_project.Logging.Entry", "Resolved",
1614 dbus::utility::DbusVariantType(*resolved));
1615 });
Adriana Kobylak400fd1f2021-01-29 09:01:30 -06001616
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001617 BMCWEB_ROUTE(
1618 app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001619 .privileges(redfish::privileges::deleteLogEntry)
1620
Ed Tanous002d39b2022-05-31 08:59:27 -07001621 .methods(boost::beast::http::verb::delete_)(
1622 [&app](const crow::Request& req,
1623 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1624 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001625 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001626 {
1627 return;
1628 }
1629 BMCWEB_LOG_DEBUG << "Do delete single event entries.";
1630
1631 std::string entryID = param;
1632
1633 dbus::utility::escapePathForDbus(entryID);
1634
1635 // Process response from Logging service.
1636 auto respHandler =
1637 [asyncResp, entryID](const boost::system::error_code ec) {
1638 BMCWEB_LOG_DEBUG << "EventLogEntry (DBus) doDelete callback: Done";
1639 if (ec)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001640 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001641 if (ec.value() == EBADR)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001642 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001643 messages::resourceNotFound(asyncResp->res, "LogEntry",
1644 entryID);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001645 return;
1646 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001647 // TODO Handle for specific error code
1648 BMCWEB_LOG_ERROR
1649 << "EventLogEntry (DBus) doDelete respHandler got error "
1650 << ec;
1651 asyncResp->res.result(
1652 boost::beast::http::status::internal_server_error);
1653 return;
1654 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001655
Ed Tanous002d39b2022-05-31 08:59:27 -07001656 asyncResp->res.result(boost::beast::http::status::ok);
1657 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001658
Ed Tanous002d39b2022-05-31 08:59:27 -07001659 // Make call to Logging service to request Delete Log
1660 crow::connections::systemBus->async_method_call(
1661 respHandler, "xyz.openbmc_project.Logging",
1662 "/xyz/openbmc_project/logging/entry/" + entryID,
1663 "xyz.openbmc_project.Object.Delete", "Delete");
Ed Tanous45ca1b82022-03-25 13:07:27 -07001664 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001665}
1666
1667inline void requestRoutesDBusEventLogEntryDownload(App& app)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001668{
George Liu0fda0f12021-11-16 10:06:17 +08001669 BMCWEB_ROUTE(
1670 app,
1671 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/attachment")
Ed Tanoused398212021-06-09 17:05:54 -07001672 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001673 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001674 [&app](const crow::Request& req,
1675 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1676 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001677 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001678 {
1679 return;
1680 }
1681 if (!http_helpers::isOctetAccepted(req.getHeaderValue("Accept")))
1682 {
1683 asyncResp->res.result(boost::beast::http::status::bad_request);
1684 return;
1685 }
zhanghch058d1b46d2021-04-01 11:18:24 +08001686
Ed Tanous002d39b2022-05-31 08:59:27 -07001687 std::string entryID = param;
1688 dbus::utility::escapePathForDbus(entryID);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001689
Ed Tanous002d39b2022-05-31 08:59:27 -07001690 crow::connections::systemBus->async_method_call(
1691 [asyncResp, entryID](const boost::system::error_code ec,
1692 const sdbusplus::message::unix_fd& unixfd) {
1693 if (ec.value() == EBADR)
1694 {
1695 messages::resourceNotFound(asyncResp->res, "EventLogAttachment",
1696 entryID);
1697 return;
1698 }
1699 if (ec)
1700 {
1701 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1702 messages::internalError(asyncResp->res);
1703 return;
1704 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001705
Ed Tanous002d39b2022-05-31 08:59:27 -07001706 int fd = -1;
1707 fd = dup(unixfd);
1708 if (fd == -1)
1709 {
1710 messages::internalError(asyncResp->res);
1711 return;
1712 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001713
Ed Tanous002d39b2022-05-31 08:59:27 -07001714 long long int size = lseek(fd, 0, SEEK_END);
1715 if (size == -1)
1716 {
1717 messages::internalError(asyncResp->res);
1718 return;
1719 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001720
Ed Tanous002d39b2022-05-31 08:59:27 -07001721 // Arbitrary max size of 64kb
1722 constexpr int maxFileSize = 65536;
1723 if (size > maxFileSize)
1724 {
1725 BMCWEB_LOG_ERROR << "File size exceeds maximum allowed size of "
1726 << maxFileSize;
1727 messages::internalError(asyncResp->res);
1728 return;
1729 }
1730 std::vector<char> data(static_cast<size_t>(size));
1731 long long int rc = lseek(fd, 0, SEEK_SET);
1732 if (rc == -1)
1733 {
1734 messages::internalError(asyncResp->res);
1735 return;
1736 }
1737 rc = read(fd, data.data(), data.size());
1738 if ((rc == -1) || (rc != size))
1739 {
1740 messages::internalError(asyncResp->res);
1741 return;
1742 }
1743 close(fd);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001744
Ed Tanous002d39b2022-05-31 08:59:27 -07001745 std::string_view strData(data.data(), data.size());
1746 std::string output = crow::utility::base64encode(strData);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001747
Ed Tanous002d39b2022-05-31 08:59:27 -07001748 asyncResp->res.addHeader("Content-Type",
1749 "application/octet-stream");
1750 asyncResp->res.addHeader("Content-Transfer-Encoding", "Base64");
1751 asyncResp->res.body() = std::move(output);
1752 },
1753 "xyz.openbmc_project.Logging",
1754 "/xyz/openbmc_project/logging/entry/" + entryID,
1755 "xyz.openbmc_project.Logging.Entry", "GetEntry");
1756 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001757}
1758
Spencer Kub7028eb2021-10-26 15:27:35 +08001759constexpr const char* hostLoggerFolderPath = "/var/log/console";
1760
1761inline bool
1762 getHostLoggerFiles(const std::string& hostLoggerFilePath,
1763 std::vector<std::filesystem::path>& hostLoggerFiles)
1764{
1765 std::error_code ec;
1766 std::filesystem::directory_iterator logPath(hostLoggerFilePath, ec);
1767 if (ec)
1768 {
1769 BMCWEB_LOG_ERROR << ec.message();
1770 return false;
1771 }
1772 for (const std::filesystem::directory_entry& it : logPath)
1773 {
1774 std::string filename = it.path().filename();
1775 // Prefix of each log files is "log". Find the file and save the
1776 // path
1777 if (boost::starts_with(filename, "log"))
1778 {
1779 hostLoggerFiles.emplace_back(it.path());
1780 }
1781 }
1782 // As the log files rotate, they are appended with a ".#" that is higher for
1783 // the older logs. Since we start from oldest logs, sort the name in
1784 // descending order.
1785 std::sort(hostLoggerFiles.rbegin(), hostLoggerFiles.rend(),
1786 AlphanumLess<std::string>());
1787
1788 return true;
1789}
1790
1791inline bool
1792 getHostLoggerEntries(std::vector<std::filesystem::path>& hostLoggerFiles,
Ed Tanousc937d2b2022-04-05 09:58:00 -07001793 uint64_t skip, uint64_t top,
Spencer Kub7028eb2021-10-26 15:27:35 +08001794 std::vector<std::string>& logEntries, size_t& logCount)
1795{
1796 GzFileReader logFile;
1797
1798 // Go though all log files and expose host logs.
1799 for (const std::filesystem::path& it : hostLoggerFiles)
1800 {
1801 if (!logFile.gzGetLines(it.string(), skip, top, logEntries, logCount))
1802 {
1803 BMCWEB_LOG_ERROR << "fail to expose host logs";
1804 return false;
1805 }
1806 }
1807 // Get lastMessage from constructor by getter
1808 std::string lastMessage = logFile.getLastMessage();
1809 if (!lastMessage.empty())
1810 {
1811 logCount++;
1812 if (logCount > skip && logCount <= (skip + top))
1813 {
1814 logEntries.push_back(lastMessage);
1815 }
1816 }
1817 return true;
1818}
1819
1820inline void fillHostLoggerEntryJson(const std::string& logEntryID,
1821 const std::string& msg,
Jason M. Bills6d6574c2022-06-28 12:30:16 -07001822 nlohmann::json::object_t& logEntryJson)
Spencer Kub7028eb2021-10-26 15:27:35 +08001823{
1824 // Fill in the log entry with the gathered data.
Jason M. Bills6d6574c2022-06-28 12:30:16 -07001825 logEntryJson["@odata.type"] = "#LogEntry.v1_4_0.LogEntry";
1826 logEntryJson["@odata.id"] =
1827 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries/" +
1828 logEntryID;
1829 logEntryJson["Name"] = "Host Logger Entry";
1830 logEntryJson["Id"] = logEntryID;
1831 logEntryJson["Message"] = msg;
1832 logEntryJson["EntryType"] = "Oem";
1833 logEntryJson["Severity"] = "OK";
1834 logEntryJson["OemRecordFormat"] = "Host Logger Entry";
Spencer Kub7028eb2021-10-26 15:27:35 +08001835}
1836
1837inline void requestRoutesSystemHostLogger(App& app)
1838{
1839 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/HostLogger/")
1840 .privileges(redfish::privileges::getLogService)
Ed Tanous14766872022-03-15 10:44:42 -07001841 .methods(boost::beast::http::verb::get)(
1842 [&app](const crow::Request& req,
1843 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001844 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001845 {
1846 return;
1847 }
1848 asyncResp->res.jsonValue["@odata.id"] =
1849 "/redfish/v1/Systems/system/LogServices/HostLogger";
1850 asyncResp->res.jsonValue["@odata.type"] =
1851 "#LogService.v1_1_0.LogService";
1852 asyncResp->res.jsonValue["Name"] = "Host Logger Service";
1853 asyncResp->res.jsonValue["Description"] = "Host Logger Service";
1854 asyncResp->res.jsonValue["Id"] = "HostLogger";
1855 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
1856 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
1857 });
Spencer Kub7028eb2021-10-26 15:27:35 +08001858}
1859
1860inline void requestRoutesSystemHostLoggerCollection(App& app)
1861{
1862 BMCWEB_ROUTE(app,
1863 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries/")
1864 .privileges(redfish::privileges::getLogEntry)
Ed Tanous002d39b2022-05-31 08:59:27 -07001865 .methods(boost::beast::http::verb::get)(
1866 [&app](const crow::Request& req,
1867 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
1868 query_param::QueryCapabilities capabilities = {
1869 .canDelegateTop = true,
1870 .canDelegateSkip = true,
1871 };
1872 query_param::Query delegatedQuery;
1873 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00001874 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07001875 {
1876 return;
1877 }
1878 asyncResp->res.jsonValue["@odata.id"] =
1879 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries";
1880 asyncResp->res.jsonValue["@odata.type"] =
1881 "#LogEntryCollection.LogEntryCollection";
1882 asyncResp->res.jsonValue["Name"] = "HostLogger Entries";
1883 asyncResp->res.jsonValue["Description"] =
1884 "Collection of HostLogger Entries";
1885 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
1886 logEntryArray = nlohmann::json::array();
1887 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Spencer Kub7028eb2021-10-26 15:27:35 +08001888
Ed Tanous002d39b2022-05-31 08:59:27 -07001889 std::vector<std::filesystem::path> hostLoggerFiles;
1890 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
1891 {
1892 BMCWEB_LOG_ERROR << "fail to get host log file path";
1893 return;
1894 }
1895
1896 size_t logCount = 0;
1897 // This vector only store the entries we want to expose that
1898 // control by skip and top.
1899 std::vector<std::string> logEntries;
1900 if (!getHostLoggerEntries(hostLoggerFiles, delegatedQuery.skip,
1901 delegatedQuery.top, logEntries, logCount))
1902 {
1903 messages::internalError(asyncResp->res);
1904 return;
1905 }
1906 // If vector is empty, that means skip value larger than total
1907 // log count
1908 if (logEntries.empty())
1909 {
1910 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
1911 return;
1912 }
1913 if (!logEntries.empty())
1914 {
1915 for (size_t i = 0; i < logEntries.size(); i++)
George Liu0fda0f12021-11-16 10:06:17 +08001916 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07001917 nlohmann::json::object_t hostLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07001918 fillHostLoggerEntryJson(std::to_string(delegatedQuery.skip + i),
1919 logEntries[i], hostLogEntry);
Jason M. Bills6d6574c2022-06-28 12:30:16 -07001920 logEntryArray.push_back(std::move(hostLogEntry));
George Liu0fda0f12021-11-16 10:06:17 +08001921 }
1922
Ed Tanous002d39b2022-05-31 08:59:27 -07001923 asyncResp->res.jsonValue["Members@odata.count"] = logCount;
1924 if (delegatedQuery.skip + delegatedQuery.top < logCount)
George Liu0fda0f12021-11-16 10:06:17 +08001925 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001926 asyncResp->res.jsonValue["Members@odata.nextLink"] =
1927 "/redfish/v1/Systems/system/LogServices/HostLogger/Entries?$skip=" +
1928 std::to_string(delegatedQuery.skip + delegatedQuery.top);
George Liu0fda0f12021-11-16 10:06:17 +08001929 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001930 }
George Liu0fda0f12021-11-16 10:06:17 +08001931 });
Spencer Kub7028eb2021-10-26 15:27:35 +08001932}
1933
1934inline void requestRoutesSystemHostLoggerLogEntry(App& app)
1935{
1936 BMCWEB_ROUTE(
1937 app, "/redfish/v1/Systems/system/LogServices/HostLogger/Entries/<str>/")
1938 .privileges(redfish::privileges::getLogEntry)
1939 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001940 [&app](const crow::Request& req,
1941 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1942 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001943 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001944 {
1945 return;
1946 }
1947 const std::string& targetID = param;
Spencer Kub7028eb2021-10-26 15:27:35 +08001948
Ed Tanous002d39b2022-05-31 08:59:27 -07001949 uint64_t idInt = 0;
Ed Tanousca45aa32022-01-07 09:28:45 -08001950
Ed Tanous002d39b2022-05-31 08:59:27 -07001951 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
1952 const char* end = targetID.data() + targetID.size();
Ed Tanousca45aa32022-01-07 09:28:45 -08001953
Ed Tanous002d39b2022-05-31 08:59:27 -07001954 auto [ptr, ec] = std::from_chars(targetID.data(), end, idInt);
1955 if (ec == std::errc::invalid_argument)
1956 {
1957 messages::resourceMissingAtURI(asyncResp->res, req.urlView);
1958 return;
1959 }
1960 if (ec == std::errc::result_out_of_range)
1961 {
1962 messages::resourceMissingAtURI(asyncResp->res, req.urlView);
1963 return;
1964 }
Spencer Kub7028eb2021-10-26 15:27:35 +08001965
Ed Tanous002d39b2022-05-31 08:59:27 -07001966 std::vector<std::filesystem::path> hostLoggerFiles;
1967 if (!getHostLoggerFiles(hostLoggerFolderPath, hostLoggerFiles))
1968 {
1969 BMCWEB_LOG_ERROR << "fail to get host log file path";
1970 return;
1971 }
Spencer Kub7028eb2021-10-26 15:27:35 +08001972
Ed Tanous002d39b2022-05-31 08:59:27 -07001973 size_t logCount = 0;
1974 uint64_t top = 1;
1975 std::vector<std::string> logEntries;
1976 // We can get specific entry by skip and top. For example, if we
1977 // want to get nth entry, we can set skip = n-1 and top = 1 to
1978 // get that entry
1979 if (!getHostLoggerEntries(hostLoggerFiles, idInt, top, logEntries,
1980 logCount))
1981 {
1982 messages::internalError(asyncResp->res);
1983 return;
1984 }
Spencer Kub7028eb2021-10-26 15:27:35 +08001985
Ed Tanous002d39b2022-05-31 08:59:27 -07001986 if (!logEntries.empty())
1987 {
Jason M. Bills6d6574c2022-06-28 12:30:16 -07001988 nlohmann::json::object_t hostLogEntry;
1989 fillHostLoggerEntryJson(targetID, logEntries[0], hostLogEntry);
1990 asyncResp->res.jsonValue.update(hostLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07001991 return;
1992 }
Spencer Kub7028eb2021-10-26 15:27:35 +08001993
Ed Tanous002d39b2022-05-31 08:59:27 -07001994 // Requested ID was not found
1995 messages::resourceMissingAtURI(asyncResp->res, req.urlView);
1996 });
Spencer Kub7028eb2021-10-26 15:27:35 +08001997}
1998
Claire Weinanfdd26902022-03-01 14:18:25 -08001999constexpr char const* dumpManagerIface =
2000 "xyz.openbmc_project.Collection.DeleteAll";
2001inline void handleLogServicesCollectionGet(
2002 crow::App& app, const crow::Request& req,
2003 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2004{
2005 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2006 {
2007 return;
2008 }
2009 // Collections don't include the static data added by SubRoute
2010 // because it has a duplicate entry for members
2011 asyncResp->res.jsonValue["@odata.type"] =
2012 "#LogServiceCollection.LogServiceCollection";
2013 asyncResp->res.jsonValue["@odata.id"] =
2014 "/redfish/v1/Managers/bmc/LogServices";
2015 asyncResp->res.jsonValue["Name"] = "Open BMC Log Services Collection";
2016 asyncResp->res.jsonValue["Description"] =
2017 "Collection of LogServices for this Manager";
2018 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
2019 logServiceArray = nlohmann::json::array();
2020
2021#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
2022 logServiceArray.push_back(
2023 {{"@odata.id", "/redfish/v1/Managers/bmc/LogServices/Journal"}});
2024#endif
2025
2026 asyncResp->res.jsonValue["Members@odata.count"] = logServiceArray.size();
2027
2028#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
2029 auto respHandler =
2030 [asyncResp](
2031 const boost::system::error_code ec,
2032 const dbus::utility::MapperGetSubTreePathsResponse& subTreePaths) {
2033 if (ec)
2034 {
2035 BMCWEB_LOG_ERROR
2036 << "handleLogServicesCollectionGet respHandler got error "
2037 << ec;
2038 // Assume that getting an error simply means there are no dump
2039 // LogServices. Return without adding any error response.
2040 return;
2041 }
2042
2043 nlohmann::json& logServiceArrayLocal =
2044 asyncResp->res.jsonValue["Members"];
2045
2046 for (const std::string& path : subTreePaths)
2047 {
2048 if (path == "/xyz/openbmc_project/dump/bmc")
2049 {
2050 logServiceArrayLocal.push_back(
2051 {{"@odata.id",
2052 "/redfish/v1/Managers/bmc/LogServices/Dump"}});
2053 }
2054 else if (path == "/xyz/openbmc_project/dump/faultlog")
2055 {
2056 logServiceArrayLocal.push_back(
2057 {{"@odata.id",
2058 "/redfish/v1/Managers/bmc/LogServices/FaultLog"}});
2059 }
2060 }
2061
2062 asyncResp->res.jsonValue["Members@odata.count"] =
2063 logServiceArrayLocal.size();
2064 };
2065
2066 crow::connections::systemBus->async_method_call(
2067 respHandler, "xyz.openbmc_project.ObjectMapper",
2068 "/xyz/openbmc_project/object_mapper",
2069 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
2070 "/xyz/openbmc_project/dump", 0,
2071 std::array<const char*, 1>{dumpManagerIface});
2072#endif
2073}
2074
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002075inline void requestRoutesBMCLogServiceCollection(App& app)
2076{
2077 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/")
Gunnar Millsad89dcf2021-07-30 14:40:11 -05002078 .privileges(redfish::privileges::getLogServiceCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002079 .methods(boost::beast::http::verb::get)(
Claire Weinanfdd26902022-03-01 14:18:25 -08002080 std::bind_front(handleLogServicesCollectionGet, std::ref(app)));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002081}
Ed Tanous1da66f72018-07-27 16:13:37 -07002082
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002083inline void requestRoutesBMCJournalLogService(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07002084{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002085 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/")
Ed Tanoused398212021-06-09 17:05:54 -07002086 .privileges(redfish::privileges::getLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002087 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002088 [&app](const crow::Request& req,
2089 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002090 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002091 {
2092 return;
2093 }
2094 asyncResp->res.jsonValue["@odata.type"] =
2095 "#LogService.v1_1_0.LogService";
2096 asyncResp->res.jsonValue["@odata.id"] =
2097 "/redfish/v1/Managers/bmc/LogServices/Journal";
2098 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Log Service";
2099 asyncResp->res.jsonValue["Description"] = "BMC Journal Log Service";
2100 asyncResp->res.jsonValue["Id"] = "BMC Journal";
2101 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05302102
Ed Tanous002d39b2022-05-31 08:59:27 -07002103 std::pair<std::string, std::string> redfishDateTimeOffset =
2104 crow::utility::getDateTimeOffsetNow();
2105 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2106 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2107 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302108
Ed Tanous002d39b2022-05-31 08:59:27 -07002109 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2110 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2111 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002112}
Jason M. Billse1f26342018-07-18 12:12:00 -07002113
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002114static int
2115 fillBMCJournalLogEntryJson(const std::string& bmcJournalLogEntryID,
2116 sd_journal* journal,
2117 nlohmann::json::object_t& bmcJournalLogEntryJson)
Jason M. Billse1f26342018-07-18 12:12:00 -07002118{
2119 // Get the Log Entry contents
2120 int ret = 0;
Jason M. Billse1f26342018-07-18 12:12:00 -07002121
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002122 std::string message;
2123 std::string_view syslogID;
2124 ret = getJournalMetadata(journal, "SYSLOG_IDENTIFIER", syslogID);
2125 if (ret < 0)
2126 {
2127 BMCWEB_LOG_ERROR << "Failed to read SYSLOG_IDENTIFIER field: "
2128 << strerror(-ret);
2129 }
2130 if (!syslogID.empty())
2131 {
2132 message += std::string(syslogID) + ": ";
2133 }
2134
Ed Tanous39e77502019-03-04 17:35:53 -08002135 std::string_view msg;
Jason M. Bills16428a12018-11-02 12:42:29 -07002136 ret = getJournalMetadata(journal, "MESSAGE", msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002137 if (ret < 0)
2138 {
2139 BMCWEB_LOG_ERROR << "Failed to read MESSAGE field: " << strerror(-ret);
2140 return 1;
2141 }
Jason M. Billsa8fe54f2020-11-20 15:57:55 -08002142 message += std::string(msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07002143
2144 // Get the severity from the PRIORITY field
Ed Tanous271584a2019-07-09 16:24:22 -07002145 long int severity = 8; // Default to an invalid priority
Jason M. Bills16428a12018-11-02 12:42:29 -07002146 ret = getJournalMetadata(journal, "PRIORITY", 10, severity);
Jason M. Billse1f26342018-07-18 12:12:00 -07002147 if (ret < 0)
2148 {
2149 BMCWEB_LOG_ERROR << "Failed to read PRIORITY field: " << strerror(-ret);
Jason M. Billse1f26342018-07-18 12:12:00 -07002150 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002151
2152 // Get the Created time from the timestamp
Jason M. Bills16428a12018-11-02 12:42:29 -07002153 std::string entryTimeStr;
2154 if (!getEntryTimestamp(journal, entryTimeStr))
Jason M. Billse1f26342018-07-18 12:12:00 -07002155 {
Jason M. Bills16428a12018-11-02 12:42:29 -07002156 return 1;
Jason M. Billse1f26342018-07-18 12:12:00 -07002157 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002158
2159 // Fill in the log entry with the gathered data
Jason M. Bills84afc482022-06-24 12:38:23 -07002160 bmcJournalLogEntryJson["@odata.type"] = "#LogEntry.v1_8_0.LogEntry";
2161 bmcJournalLogEntryJson["@odata.id"] =
2162 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/" +
2163 bmcJournalLogEntryID;
2164 bmcJournalLogEntryJson["Name"] = "BMC Journal Entry";
2165 bmcJournalLogEntryJson["Id"] = bmcJournalLogEntryID;
2166 bmcJournalLogEntryJson["Message"] = std::move(message);
2167 bmcJournalLogEntryJson["EntryType"] = "Oem";
2168 bmcJournalLogEntryJson["Severity"] = severity <= 2 ? "Critical"
2169 : severity <= 4 ? "Warning"
2170 : "OK";
2171 bmcJournalLogEntryJson["OemRecordFormat"] = "BMC Journal Entry";
2172 bmcJournalLogEntryJson["Created"] = std::move(entryTimeStr);
Jason M. Billse1f26342018-07-18 12:12:00 -07002173 return 0;
2174}
2175
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002176inline void requestRoutesBMCJournalLogEntryCollection(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002177{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002178 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002179 .privileges(redfish::privileges::getLogEntryCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07002180 .methods(boost::beast::http::verb::get)(
2181 [&app](const crow::Request& req,
2182 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
2183 query_param::QueryCapabilities capabilities = {
2184 .canDelegateTop = true,
2185 .canDelegateSkip = true,
2186 };
2187 query_param::Query delegatedQuery;
2188 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00002189 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07002190 {
2191 return;
2192 }
2193 // Collections don't include the static data added by SubRoute
2194 // because it has a duplicate entry for members
2195 asyncResp->res.jsonValue["@odata.type"] =
2196 "#LogEntryCollection.LogEntryCollection";
2197 asyncResp->res.jsonValue["@odata.id"] =
2198 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
2199 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Entries";
2200 asyncResp->res.jsonValue["Description"] =
2201 "Collection of BMC Journal Entries";
2202 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
2203 logEntryArray = nlohmann::json::array();
Jason M. Billse1f26342018-07-18 12:12:00 -07002204
Ed Tanous002d39b2022-05-31 08:59:27 -07002205 // Go through the journal and use the timestamp to create a
2206 // unique ID for each entry
2207 sd_journal* journalTmp = nullptr;
2208 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2209 if (ret < 0)
2210 {
2211 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
2212 messages::internalError(asyncResp->res);
2213 return;
2214 }
2215 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2216 journalTmp, sd_journal_close);
2217 journalTmp = nullptr;
2218 uint64_t entryCount = 0;
2219 // Reset the unique ID on the first entry
2220 bool firstEntry = true;
2221 SD_JOURNAL_FOREACH(journal.get())
2222 {
2223 entryCount++;
2224 // Handle paging using skip (number of entries to skip from
2225 // the start) and top (number of entries to display)
2226 if (entryCount <= delegatedQuery.skip ||
2227 entryCount > delegatedQuery.skip + delegatedQuery.top)
George Liu0fda0f12021-11-16 10:06:17 +08002228 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002229 continue;
2230 }
2231
2232 std::string idStr;
2233 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2234 {
2235 continue;
2236 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002237 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002238
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002239 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002240 if (fillBMCJournalLogEntryJson(idStr, journal.get(),
2241 bmcJournalLogEntry) != 0)
2242 {
George Liu0fda0f12021-11-16 10:06:17 +08002243 messages::internalError(asyncResp->res);
2244 return;
2245 }
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002246 logEntryArray.push_back(std::move(bmcJournalLogEntry));
Ed Tanous002d39b2022-05-31 08:59:27 -07002247 }
2248 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
2249 if (delegatedQuery.skip + delegatedQuery.top < entryCount)
2250 {
2251 asyncResp->res.jsonValue["Members@odata.nextLink"] =
2252 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries?$skip=" +
2253 std::to_string(delegatedQuery.skip + delegatedQuery.top);
2254 }
George Liu0fda0f12021-11-16 10:06:17 +08002255 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002256}
Jason M. Billse1f26342018-07-18 12:12:00 -07002257
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002258inline void requestRoutesBMCJournalLogEntry(App& app)
Jason M. Billse1f26342018-07-18 12:12:00 -07002259{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002260 BMCWEB_ROUTE(app,
2261 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002262 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002263 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002264 [&app](const crow::Request& req,
2265 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2266 const std::string& entryID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002267 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002268 {
2269 return;
2270 }
2271 // Convert the unique ID back to a timestamp to find the entry
2272 uint64_t ts = 0;
2273 uint64_t index = 0;
2274 if (!getTimestampFromID(asyncResp, entryID, ts, index))
2275 {
2276 return;
2277 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002278
Ed Tanous002d39b2022-05-31 08:59:27 -07002279 sd_journal* journalTmp = nullptr;
2280 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
2281 if (ret < 0)
2282 {
2283 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
2284 messages::internalError(asyncResp->res);
2285 return;
2286 }
2287 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
2288 journalTmp, sd_journal_close);
2289 journalTmp = nullptr;
2290 // Go to the timestamp in the log and move to the entry at the
2291 // index tracking the unique ID
2292 std::string idStr;
2293 bool firstEntry = true;
2294 ret = sd_journal_seek_realtime_usec(journal.get(), ts);
2295 if (ret < 0)
2296 {
2297 BMCWEB_LOG_ERROR << "failed to seek to an entry in journal"
2298 << strerror(-ret);
2299 messages::internalError(asyncResp->res);
2300 return;
2301 }
2302 for (uint64_t i = 0; i <= index; i++)
2303 {
2304 sd_journal_next(journal.get());
2305 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
2306 {
2307 messages::internalError(asyncResp->res);
2308 return;
2309 }
Jason M. Billsefde4ec2022-06-24 08:59:52 -07002310 firstEntry = false;
Ed Tanous002d39b2022-05-31 08:59:27 -07002311 }
2312 // Confirm that the entry ID matches what was requested
2313 if (idStr != entryID)
2314 {
2315 messages::resourceMissingAtURI(asyncResp->res, req.urlView);
2316 return;
2317 }
zhanghch058d1b46d2021-04-01 11:18:24 +08002318
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002319 nlohmann::json::object_t bmcJournalLogEntry;
Ed Tanous002d39b2022-05-31 08:59:27 -07002320 if (fillBMCJournalLogEntryJson(entryID, journal.get(),
Jason M. Bills3a48b3a2022-06-24 10:10:15 -07002321 bmcJournalLogEntry) != 0)
Ed Tanous002d39b2022-05-31 08:59:27 -07002322 {
2323 messages::internalError(asyncResp->res);
2324 return;
2325 }
Jason M. Billsd405bb52022-06-24 10:52:05 -07002326 asyncResp->res.jsonValue.update(bmcJournalLogEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002327 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002328}
2329
Claire Weinanfdd26902022-03-01 14:18:25 -08002330inline void
2331 getDumpServiceInfo(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2332 const std::string& dumpType)
2333{
2334 std::string dumpPath;
2335 std::string overWritePolicy;
2336 bool collectDiagnosticDataSupported = false;
2337
2338 if (dumpType == "BMC")
2339 {
2340 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump";
2341 overWritePolicy = "WrapsWhenFull";
2342 collectDiagnosticDataSupported = true;
2343 }
2344 else if (dumpType == "FaultLog")
2345 {
2346 dumpPath = "/redfish/v1/Managers/bmc/LogServices/FaultLog";
2347 overWritePolicy = "Unknown";
2348 collectDiagnosticDataSupported = false;
2349 }
2350 else if (dumpType == "System")
2351 {
2352 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump";
2353 overWritePolicy = "WrapsWhenFull";
2354 collectDiagnosticDataSupported = true;
2355 }
2356 else
2357 {
2358 BMCWEB_LOG_ERROR << "getDumpServiceInfo() invalid dump type: "
2359 << dumpType;
2360 messages::internalError(asyncResp->res);
2361 return;
2362 }
2363
2364 asyncResp->res.jsonValue["@odata.id"] = dumpPath;
2365 asyncResp->res.jsonValue["@odata.type"] = "#LogService.v1_2_0.LogService";
2366 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2367 asyncResp->res.jsonValue["Description"] = dumpType + " Dump LogService";
2368 asyncResp->res.jsonValue["Id"] = std::filesystem::path(dumpPath).filename();
2369 asyncResp->res.jsonValue["OverWritePolicy"] = std::move(overWritePolicy);
2370
2371 std::pair<std::string, std::string> redfishDateTimeOffset =
2372 crow::utility::getDateTimeOffsetNow();
2373 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2374 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2375 redfishDateTimeOffset.second;
2376
2377 asyncResp->res.jsonValue["Entries"]["@odata.id"] = dumpPath + "/Entries";
2378 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
2379 dumpPath + "/Actions/LogService.ClearLog";
2380
2381 if (collectDiagnosticDataSupported)
2382 {
2383 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
2384 ["target"] =
2385 dumpPath + "/Actions/LogService.CollectDiagnosticData";
2386 }
2387}
2388
2389inline void handleLogServicesDumpServiceGet(
2390 crow::App& app, const std::string& dumpType, const crow::Request& req,
2391 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2392{
2393 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2394 {
2395 return;
2396 }
2397 getDumpServiceInfo(asyncResp, dumpType);
2398}
2399
2400inline void handleLogServicesDumpEntriesCollectionGet(
2401 crow::App& app, const std::string& dumpType, const crow::Request& req,
2402 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2403{
2404 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2405 {
2406 return;
2407 }
2408 getDumpEntryCollection(asyncResp, dumpType);
2409}
2410
2411inline void handleLogServicesDumpEntryGet(
2412 crow::App& app, const std::string& dumpType, const crow::Request& req,
2413 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2414 const std::string& dumpId)
2415{
2416 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2417 {
2418 return;
2419 }
2420 getDumpEntryById(asyncResp, dumpId, dumpType);
2421}
2422
2423inline void handleLogServicesDumpEntryDelete(
2424 crow::App& app, const std::string& dumpType, const crow::Request& req,
2425 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2426 const std::string& dumpId)
2427{
2428 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2429 {
2430 return;
2431 }
2432 deleteDumpEntry(asyncResp, dumpId, dumpType);
2433}
2434
2435inline void handleLogServicesDumpCollectDiagnosticDataPost(
2436 crow::App& app, const std::string& dumpType, const crow::Request& req,
2437 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2438{
2439 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2440 {
2441 return;
2442 }
2443 createDump(asyncResp, req, dumpType);
2444}
2445
2446inline void handleLogServicesDumpClearLogPost(
2447 crow::App& app, const std::string& dumpType, const crow::Request& req,
2448 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
2449{
2450 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
2451 {
2452 return;
2453 }
2454 clearDump(asyncResp, dumpType);
2455}
2456
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002457inline void requestRoutesBMCDumpService(App& app)
2458{
2459 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07002460 .privileges(redfish::privileges::getLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002461 .methods(boost::beast::http::verb::get)(std::bind_front(
2462 handleLogServicesDumpServiceGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002463}
2464
2465inline void requestRoutesBMCDumpEntryCollection(App& app)
2466{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002467 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002468 .privileges(redfish::privileges::getLogEntryCollection)
Claire Weinanfdd26902022-03-01 14:18:25 -08002469 .methods(boost::beast::http::verb::get)(std::bind_front(
2470 handleLogServicesDumpEntriesCollectionGet, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002471}
2472
2473inline void requestRoutesBMCDumpEntry(App& app)
2474{
2475 BMCWEB_ROUTE(app,
2476 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002477 .privileges(redfish::privileges::getLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002478 .methods(boost::beast::http::verb::get)(std::bind_front(
2479 handleLogServicesDumpEntryGet, std::ref(app), "BMC"));
2480
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002481 BMCWEB_ROUTE(app,
2482 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002483 .privileges(redfish::privileges::deleteLogEntry)
Claire Weinanfdd26902022-03-01 14:18:25 -08002484 .methods(boost::beast::http::verb::delete_)(std::bind_front(
2485 handleLogServicesDumpEntryDelete, std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002486}
2487
2488inline void requestRoutesBMCDumpCreate(App& app)
2489{
George Liu0fda0f12021-11-16 10:06:17 +08002490 BMCWEB_ROUTE(
2491 app,
2492 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07002493 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002494 .methods(boost::beast::http::verb::post)(
Claire Weinanfdd26902022-03-01 14:18:25 -08002495 std::bind_front(handleLogServicesDumpCollectDiagnosticDataPost,
2496 std::ref(app), "BMC"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002497}
2498
2499inline void requestRoutesBMCDumpClear(App& app)
2500{
George Liu0fda0f12021-11-16 10:06:17 +08002501 BMCWEB_ROUTE(
2502 app,
2503 "/redfish/v1/Managers/bmc/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07002504 .privileges(redfish::privileges::postLogService)
Claire Weinanfdd26902022-03-01 14:18:25 -08002505 .methods(boost::beast::http::verb::post)(std::bind_front(
2506 handleLogServicesDumpClearLogPost, std::ref(app), "BMC"));
2507}
2508
2509inline void requestRoutesFaultLogDumpService(App& app)
2510{
2511 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/")
2512 .privileges(redfish::privileges::getLogService)
2513 .methods(boost::beast::http::verb::get)(std::bind_front(
2514 handleLogServicesDumpServiceGet, std::ref(app), "FaultLog"));
2515}
2516
2517inline void requestRoutesFaultLogDumpEntryCollection(App& app)
2518{
2519 BMCWEB_ROUTE(app, "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/")
2520 .privileges(redfish::privileges::getLogEntryCollection)
2521 .methods(boost::beast::http::verb::get)(
2522 std::bind_front(handleLogServicesDumpEntriesCollectionGet,
2523 std::ref(app), "FaultLog"));
2524}
2525
2526inline void requestRoutesFaultLogDumpEntry(App& app)
2527{
2528 BMCWEB_ROUTE(app,
2529 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
2530 .privileges(redfish::privileges::getLogEntry)
2531 .methods(boost::beast::http::verb::get)(std::bind_front(
2532 handleLogServicesDumpEntryGet, std::ref(app), "FaultLog"));
2533
2534 BMCWEB_ROUTE(app,
2535 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Entries/<str>/")
2536 .privileges(redfish::privileges::deleteLogEntry)
2537 .methods(boost::beast::http::verb::delete_)(std::bind_front(
2538 handleLogServicesDumpEntryDelete, std::ref(app), "FaultLog"));
2539}
2540
2541inline void requestRoutesFaultLogDumpClear(App& app)
2542{
2543 BMCWEB_ROUTE(
2544 app,
2545 "/redfish/v1/Managers/bmc/LogServices/FaultLog/Actions/LogService.ClearLog/")
2546 .privileges(redfish::privileges::postLogService)
2547 .methods(boost::beast::http::verb::post)(std::bind_front(
2548 handleLogServicesDumpClearLogPost, std::ref(app), "FaultLog"));
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002549}
2550
2551inline void requestRoutesSystemDumpService(App& app)
2552{
2553 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/")
Ed Tanoused398212021-06-09 17:05:54 -07002554 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07002555 .methods(boost::beast::http::verb::get)(
2556 [&app](const crow::Request& req,
2557 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002558 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002559 {
2560 return;
2561 }
2562 asyncResp->res.jsonValue["@odata.id"] =
2563 "/redfish/v1/Systems/system/LogServices/Dump";
2564 asyncResp->res.jsonValue["@odata.type"] =
2565 "#LogService.v1_2_0.LogService";
2566 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2567 asyncResp->res.jsonValue["Description"] = "System Dump LogService";
2568 asyncResp->res.jsonValue["Id"] = "Dump";
2569 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Tejas Patil7c8c4052021-06-04 17:43:14 +05302570
Ed Tanous002d39b2022-05-31 08:59:27 -07002571 std::pair<std::string, std::string> redfishDateTimeOffset =
2572 crow::utility::getDateTimeOffsetNow();
2573 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2574 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2575 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302576
Ed Tanous002d39b2022-05-31 08:59:27 -07002577 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2578 "/redfish/v1/Systems/system/LogServices/Dump/Entries";
2579 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
2580 "/redfish/v1/Systems/system/LogServices/Dump/Actions/LogService.ClearLog";
Ed Tanous14766872022-03-15 10:44:42 -07002581
Ed Tanous002d39b2022-05-31 08:59:27 -07002582 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
2583 ["target"] =
2584 "/redfish/v1/Systems/system/LogServices/Dump/Actions/LogService.CollectDiagnosticData";
Ed Tanous45ca1b82022-03-25 13:07:27 -07002585 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002586}
2587
2588inline void requestRoutesSystemDumpEntryCollection(App& app)
2589{
2590
2591 /**
2592 * Functions triggers appropriate requests on DBus
2593 */
Asmitha Karunanithib2a32892021-07-13 11:56:15 -05002594 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Dump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002595 .privileges(redfish::privileges::getLogEntryCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002596 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002597 [&app](const crow::Request& req,
2598 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002599 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002600 {
2601 return;
2602 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002603 getDumpEntryCollection(asyncResp, "System");
2604 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002605}
2606
2607inline void requestRoutesSystemDumpEntry(App& app)
2608{
2609 BMCWEB_ROUTE(app,
John Edward Broadbent864d6a12021-06-09 10:12:48 -07002610 "/redfish/v1/Systems/system/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002611 .privileges(redfish::privileges::getLogEntry)
2612
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002613 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002614 [&app](const crow::Request& req,
2615 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2616 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002617 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Claire Weinanc7a6d662022-06-13 16:36:39 -07002618 {
2619 return;
2620 }
2621 getDumpEntryById(asyncResp, param, "System");
Ed Tanous002d39b2022-05-31 08:59:27 -07002622 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002623
2624 BMCWEB_ROUTE(app,
John Edward Broadbent864d6a12021-06-09 10:12:48 -07002625 "/redfish/v1/Systems/system/LogServices/Dump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002626 .privileges(redfish::privileges::deleteLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002627 .methods(boost::beast::http::verb::delete_)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002628 [&app](const crow::Request& req,
2629 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2630 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002631 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002632 {
2633 return;
2634 }
2635 deleteDumpEntry(asyncResp, param, "system");
2636 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002637}
2638
2639inline void requestRoutesSystemDumpCreate(App& app)
2640{
George Liu0fda0f12021-11-16 10:06:17 +08002641 BMCWEB_ROUTE(
2642 app,
2643 "/redfish/v1/Systems/system/LogServices/Dump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07002644 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002645 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002646 [&app](const crow::Request& req,
2647 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002648 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002649 {
2650 return;
2651 }
2652 createDump(asyncResp, req, "System");
2653 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002654}
2655
2656inline void requestRoutesSystemDumpClear(App& app)
2657{
George Liu0fda0f12021-11-16 10:06:17 +08002658 BMCWEB_ROUTE(
2659 app,
2660 "/redfish/v1/Systems/system/LogServices/Dump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07002661 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002662 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002663 [&app](const crow::Request& req,
2664 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002665
Ed Tanous45ca1b82022-03-25 13:07:27 -07002666 {
Carson Labrado3ba00072022-06-06 19:40:56 +00002667 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002668 {
2669 return;
2670 }
2671 clearDump(asyncResp, "System");
2672 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002673}
2674
2675inline void requestRoutesCrashdumpService(App& app)
2676{
2677 // Note: Deviated from redfish privilege registry for GET & HEAD
2678 // method for security reasons.
2679 /**
2680 * Functions triggers appropriate requests on DBus
2681 */
2682 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/Crashdump/")
Ed Tanoused398212021-06-09 17:05:54 -07002683 // This is incorrect, should be:
2684 //.privileges(redfish::privileges::getLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07002685 .privileges({{"ConfigureManager"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07002686 .methods(boost::beast::http::verb::get)(
2687 [&app](const crow::Request& req,
2688 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002689 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002690 {
2691 return;
2692 }
2693 // Copy over the static data to include the entries added by
2694 // SubRoute
2695 asyncResp->res.jsonValue["@odata.id"] =
2696 "/redfish/v1/Systems/system/LogServices/Crashdump";
2697 asyncResp->res.jsonValue["@odata.type"] =
2698 "#LogService.v1_2_0.LogService";
2699 asyncResp->res.jsonValue["Name"] = "Open BMC Oem Crashdump Service";
2700 asyncResp->res.jsonValue["Description"] = "Oem Crashdump Service";
2701 asyncResp->res.jsonValue["Id"] = "Oem Crashdump";
2702 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
2703 asyncResp->res.jsonValue["MaxNumberOfRecords"] = 3;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302704
Ed Tanous002d39b2022-05-31 08:59:27 -07002705 std::pair<std::string, std::string> redfishDateTimeOffset =
2706 crow::utility::getDateTimeOffsetNow();
2707 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
2708 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
2709 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05302710
Ed Tanous002d39b2022-05-31 08:59:27 -07002711 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
2712 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
2713 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"]["target"] =
2714 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.ClearLog";
2715 asyncResp->res.jsonValue["Actions"]["#LogService.CollectDiagnosticData"]
2716 ["target"] =
2717 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData";
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002718 });
2719}
2720
2721void inline requestRoutesCrashdumpClear(App& app)
2722{
George Liu0fda0f12021-11-16 10:06:17 +08002723 BMCWEB_ROUTE(
2724 app,
2725 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07002726 // This is incorrect, should be:
2727 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07002728 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002729 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002730 [&app](const crow::Request& req,
2731 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002732 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002733 {
2734 return;
2735 }
2736 crow::connections::systemBus->async_method_call(
2737 [asyncResp](const boost::system::error_code ec,
2738 const std::string&) {
2739 if (ec)
2740 {
2741 messages::internalError(asyncResp->res);
2742 return;
2743 }
2744 messages::success(asyncResp->res);
2745 },
2746 crashdumpObject, crashdumpPath, deleteAllInterface, "DeleteAll");
2747 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002748}
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002749
zhanghch058d1b46d2021-04-01 11:18:24 +08002750static void
2751 logCrashdumpEntry(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2752 const std::string& logID, nlohmann::json& logEntryJson)
Jason M. Billse855dd22019-10-08 11:37:48 -07002753{
Johnathan Mantey043a0532020-03-10 17:15:28 -07002754 auto getStoredLogCallback =
Ed Tanousb9d36b42022-02-26 21:42:46 -08002755 [asyncResp, logID,
2756 &logEntryJson](const boost::system::error_code ec,
2757 const dbus::utility::DBusPropertiesMap& params) {
Ed Tanous002d39b2022-05-31 08:59:27 -07002758 if (ec)
2759 {
2760 BMCWEB_LOG_DEBUG << "failed to get log ec: " << ec.message();
2761 if (ec.value() ==
2762 boost::system::linux_error::bad_request_descriptor)
Jason M. Bills1ddcf012019-11-26 14:59:21 -08002763 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002764 messages::resourceNotFound(asyncResp->res, "LogEntry", logID);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08002765 }
2766 else
2767 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002768 messages::internalError(asyncResp->res);
Jason M. Bills2b20ef62022-01-06 15:48:07 -08002769 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002770 return;
2771 }
2772
2773 std::string timestamp{};
2774 std::string filename{};
2775 std::string logfile{};
2776 parseCrashdumpParameters(params, filename, timestamp, logfile);
2777
2778 if (filename.empty() || timestamp.empty())
2779 {
2780 messages::resourceMissingAtURI(asyncResp->res,
2781 crow::utility::urlFromPieces(logID));
2782 return;
2783 }
2784
2785 std::string crashdumpURI =
2786 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/" +
2787 logID + "/" + filename;
Jason M. Bills84afc482022-06-24 12:38:23 -07002788 nlohmann::json::object_t logEntry;
2789 logEntry["@odata.type"] = "#LogEntry.v1_7_0.LogEntry";
2790 logEntry["@odata.id"] =
2791 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/" + logID;
2792 logEntry["Name"] = "CPU Crashdump";
2793 logEntry["Id"] = logID;
2794 logEntry["EntryType"] = "Oem";
2795 logEntry["AdditionalDataURI"] = std::move(crashdumpURI);
2796 logEntry["DiagnosticDataType"] = "OEM";
2797 logEntry["OEMDiagnosticDataType"] = "PECICrashdump";
2798 logEntry["Created"] = std::move(timestamp);
Ed Tanous002d39b2022-05-31 08:59:27 -07002799
2800 // If logEntryJson references an array of LogEntry resources
2801 // ('Members' list), then push this as a new entry, otherwise set it
2802 // directly
2803 if (logEntryJson.is_array())
2804 {
2805 logEntryJson.push_back(logEntry);
2806 asyncResp->res.jsonValue["Members@odata.count"] =
2807 logEntryJson.size();
2808 }
2809 else
2810 {
Jason M. Billsd405bb52022-06-24 10:52:05 -07002811 logEntryJson.update(logEntry);
Ed Tanous002d39b2022-05-31 08:59:27 -07002812 }
2813 };
Jason M. Billse855dd22019-10-08 11:37:48 -07002814 crow::connections::systemBus->async_method_call(
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002815 std::move(getStoredLogCallback), crashdumpObject,
2816 crashdumpPath + std::string("/") + logID,
Johnathan Mantey043a0532020-03-10 17:15:28 -07002817 "org.freedesktop.DBus.Properties", "GetAll", crashdumpInterface);
Jason M. Billse855dd22019-10-08 11:37:48 -07002818}
2819
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002820inline void requestRoutesCrashdumpEntryCollection(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07002821{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002822 // Note: Deviated from redfish privilege registry for GET & HEAD
2823 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002824 /**
2825 * Functions triggers appropriate requests on DBus
2826 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002827 BMCWEB_ROUTE(app,
2828 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07002829 // This is incorrect, should be.
2830 //.privileges(redfish::privileges::postLogEntryCollection)
Ed Tanous432a8902021-06-14 15:28:56 -07002831 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07002832 .methods(boost::beast::http::verb::get)(
2833 [&app](const crow::Request& req,
2834 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002835 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002836 {
2837 return;
2838 }
2839 crow::connections::systemBus->async_method_call(
2840 [asyncResp](const boost::system::error_code ec,
2841 const std::vector<std::string>& resp) {
2842 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07002843 {
Ed Tanous002d39b2022-05-31 08:59:27 -07002844 if (ec.value() !=
2845 boost::system::errc::no_such_file_or_directory)
2846 {
2847 BMCWEB_LOG_DEBUG << "failed to get entries ec: "
2848 << ec.message();
2849 messages::internalError(asyncResp->res);
2850 return;
2851 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07002852 }
Ed Tanous002d39b2022-05-31 08:59:27 -07002853 asyncResp->res.jsonValue["@odata.type"] =
2854 "#LogEntryCollection.LogEntryCollection";
2855 asyncResp->res.jsonValue["@odata.id"] =
2856 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
2857 asyncResp->res.jsonValue["Name"] = "Open BMC Crashdump Entries";
2858 asyncResp->res.jsonValue["Description"] =
2859 "Collection of Crashdump Entries";
2860 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
2861 asyncResp->res.jsonValue["Members@odata.count"] = 0;
Jason M. Bills2b20ef62022-01-06 15:48:07 -08002862
Ed Tanous002d39b2022-05-31 08:59:27 -07002863 for (const std::string& path : resp)
2864 {
2865 const sdbusplus::message::object_path objPath(path);
2866 // Get the log ID
2867 std::string logID = objPath.filename();
2868 if (logID.empty())
2869 {
2870 continue;
2871 }
2872 // Add the log entry to the array
2873 logCrashdumpEntry(asyncResp, logID,
2874 asyncResp->res.jsonValue["Members"]);
2875 }
2876 },
2877 "xyz.openbmc_project.ObjectMapper",
2878 "/xyz/openbmc_project/object_mapper",
2879 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "", 0,
2880 std::array<const char*, 1>{crashdumpInterface});
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002881 });
2882}
Ed Tanous1da66f72018-07-27 16:13:37 -07002883
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002884inline void requestRoutesCrashdumpEntry(App& app)
Ed Tanous1da66f72018-07-27 16:13:37 -07002885{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002886 // Note: Deviated from redfish privilege registry for GET & HEAD
2887 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002888
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002889 BMCWEB_ROUTE(
2890 app, "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002891 // this is incorrect, should be
2892 // .privileges(redfish::privileges::getLogEntry)
Ed Tanous432a8902021-06-14 15:28:56 -07002893 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002894 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002895 [&app](const crow::Request& req,
2896 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2897 const std::string& param) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002898 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002899 {
2900 return;
2901 }
2902 const std::string& logID = param;
2903 logCrashdumpEntry(asyncResp, logID, asyncResp->res.jsonValue);
2904 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002905}
Ed Tanous1da66f72018-07-27 16:13:37 -07002906
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002907inline void requestRoutesCrashdumpFile(App& app)
2908{
2909 // Note: Deviated from redfish privilege registry for GET & HEAD
2910 // method for security reasons.
2911 BMCWEB_ROUTE(
2912 app,
2913 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07002914 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002915 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07002916 [&app](const crow::Request& req,
2917 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
2918 const std::string& logID, const std::string& fileName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00002919 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07002920 {
2921 return;
2922 }
2923 auto getStoredLogCallback =
2924 [asyncResp, logID, fileName, url(boost::urls::url(req.urlView))](
2925 const boost::system::error_code ec,
2926 const std::vector<
2927 std::pair<std::string, dbus::utility::DbusVariantType>>&
2928 resp) {
2929 if (ec)
2930 {
2931 BMCWEB_LOG_DEBUG << "failed to get log ec: " << ec.message();
2932 messages::internalError(asyncResp->res);
2933 return;
2934 }
Jason M. Bills8e6c0992021-03-11 16:26:53 -08002935
Ed Tanous002d39b2022-05-31 08:59:27 -07002936 std::string dbusFilename{};
2937 std::string dbusTimestamp{};
2938 std::string dbusFilepath{};
Jason M. Bills8e6c0992021-03-11 16:26:53 -08002939
Ed Tanous002d39b2022-05-31 08:59:27 -07002940 parseCrashdumpParameters(resp, dbusFilename, dbusTimestamp,
2941 dbusFilepath);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002942
Ed Tanous002d39b2022-05-31 08:59:27 -07002943 if (dbusFilename.empty() || dbusTimestamp.empty() ||
2944 dbusFilepath.empty())
2945 {
2946 messages::resourceMissingAtURI(asyncResp->res, url);
2947 return;
2948 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002949
Ed Tanous002d39b2022-05-31 08:59:27 -07002950 // Verify the file name parameter is correct
2951 if (fileName != dbusFilename)
2952 {
2953 messages::resourceMissingAtURI(asyncResp->res, url);
2954 return;
2955 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002956
Ed Tanous002d39b2022-05-31 08:59:27 -07002957 if (!std::filesystem::exists(dbusFilepath))
2958 {
2959 messages::resourceMissingAtURI(asyncResp->res, url);
2960 return;
2961 }
2962 std::ifstream ifs(dbusFilepath, std::ios::in | std::ios::binary);
2963 asyncResp->res.body() =
2964 std::string(std::istreambuf_iterator<char>{ifs}, {});
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002965
Ed Tanous002d39b2022-05-31 08:59:27 -07002966 // Configure this to be a file download when accessed
2967 // from a browser
2968 asyncResp->res.addHeader("Content-Disposition", "attachment");
2969 };
2970 crow::connections::systemBus->async_method_call(
2971 std::move(getStoredLogCallback), crashdumpObject,
2972 crashdumpPath + std::string("/") + logID,
2973 "org.freedesktop.DBus.Properties", "GetAll", crashdumpInterface);
2974 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002975}
2976
Jason M. Billsc5a4c822022-01-06 15:51:23 -08002977enum class OEMDiagnosticType
2978{
2979 onDemand,
2980 telemetry,
2981 invalid,
2982};
2983
Ed Tanousf7725d72022-03-07 12:46:00 -08002984inline OEMDiagnosticType
2985 getOEMDiagnosticType(const std::string_view& oemDiagStr)
Jason M. Billsc5a4c822022-01-06 15:51:23 -08002986{
2987 if (oemDiagStr == "OnDemand")
2988 {
2989 return OEMDiagnosticType::onDemand;
2990 }
2991 if (oemDiagStr == "Telemetry")
2992 {
2993 return OEMDiagnosticType::telemetry;
2994 }
2995
2996 return OEMDiagnosticType::invalid;
2997}
2998
John Edward Broadbent7e860f12021-04-08 15:57:16 -07002999inline void requestRoutesCrashdumpCollect(App& app)
3000{
3001 // Note: Deviated from redfish privilege registry for GET & HEAD
3002 // method for security reasons.
George Liu0fda0f12021-11-16 10:06:17 +08003003 BMCWEB_ROUTE(
3004 app,
3005 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/LogService.CollectDiagnosticData/")
Ed Tanoused398212021-06-09 17:05:54 -07003006 // The below is incorrect; Should be ConfigureManager
3007 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003008 .privileges({{"ConfigureComponents"}})
Ed Tanous002d39b2022-05-31 08:59:27 -07003009 .methods(boost::beast::http::verb::post)(
3010 [&app](const crow::Request& req,
3011 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003012 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003013 {
3014 return;
3015 }
3016 std::string diagnosticDataType;
3017 std::string oemDiagnosticDataType;
3018 if (!redfish::json_util::readJsonAction(
3019 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
3020 "OEMDiagnosticDataType", oemDiagnosticDataType))
3021 {
3022 return;
3023 }
3024
3025 if (diagnosticDataType != "OEM")
3026 {
3027 BMCWEB_LOG_ERROR
3028 << "Only OEM DiagnosticDataType supported for Crashdump";
3029 messages::actionParameterValueFormatError(
3030 asyncResp->res, diagnosticDataType, "DiagnosticDataType",
3031 "CollectDiagnosticData");
3032 return;
3033 }
3034
3035 OEMDiagnosticType oemDiagType =
3036 getOEMDiagnosticType(oemDiagnosticDataType);
3037
3038 std::string iface;
3039 std::string method;
3040 std::string taskMatchStr;
3041 if (oemDiagType == OEMDiagnosticType::onDemand)
3042 {
3043 iface = crashdumpOnDemandInterface;
3044 method = "GenerateOnDemandLog";
3045 taskMatchStr = "type='signal',"
3046 "interface='org.freedesktop.DBus.Properties',"
3047 "member='PropertiesChanged',"
3048 "arg0namespace='com.intel.crashdump'";
3049 }
3050 else if (oemDiagType == OEMDiagnosticType::telemetry)
3051 {
3052 iface = crashdumpTelemetryInterface;
3053 method = "GenerateTelemetryLog";
3054 taskMatchStr = "type='signal',"
3055 "interface='org.freedesktop.DBus.Properties',"
3056 "member='PropertiesChanged',"
3057 "arg0namespace='com.intel.crashdump'";
3058 }
3059 else
3060 {
3061 BMCWEB_LOG_ERROR << "Unsupported OEMDiagnosticDataType: "
3062 << oemDiagnosticDataType;
3063 messages::actionParameterValueFormatError(
3064 asyncResp->res, oemDiagnosticDataType, "OEMDiagnosticDataType",
3065 "CollectDiagnosticData");
3066 return;
3067 }
3068
3069 auto collectCrashdumpCallback =
3070 [asyncResp, payload(task::Payload(req)),
3071 taskMatchStr](const boost::system::error_code ec,
3072 const std::string&) mutable {
3073 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07003074 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003075 if (ec.value() == boost::system::errc::operation_not_supported)
3076 {
3077 messages::resourceInStandby(asyncResp->res);
3078 }
3079 else if (ec.value() ==
3080 boost::system::errc::device_or_resource_busy)
3081 {
3082 messages::serviceTemporarilyUnavailable(asyncResp->res,
3083 "60");
3084 }
3085 else
3086 {
3087 messages::internalError(asyncResp->res);
3088 }
Ed Tanous45ca1b82022-03-25 13:07:27 -07003089 return;
3090 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003091 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
3092 [](boost::system::error_code err, sdbusplus::message::message&,
3093 const std::shared_ptr<task::TaskData>& taskData) {
3094 if (!err)
3095 {
3096 taskData->messages.emplace_back(messages::taskCompletedOK(
3097 std::to_string(taskData->index)));
3098 taskData->state = "Completed";
3099 }
3100 return task::completed;
3101 },
3102 taskMatchStr);
Ed Tanous1da66f72018-07-27 16:13:37 -07003103
Ed Tanous002d39b2022-05-31 08:59:27 -07003104 task->startTimer(std::chrono::minutes(5));
3105 task->populateResp(asyncResp->res);
3106 task->payload.emplace(std::move(payload));
3107 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003108
Ed Tanous002d39b2022-05-31 08:59:27 -07003109 crow::connections::systemBus->async_method_call(
3110 std::move(collectCrashdumpCallback), crashdumpObject, crashdumpPath,
3111 iface, method);
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003112 });
3113}
Kenny L. Ku6eda7682020-06-19 09:48:36 -07003114
Andrew Geisslercb92c032018-08-17 07:56:14 -07003115/**
3116 * DBusLogServiceActionsClear class supports POST method for ClearLog action.
3117 */
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003118inline void requestRoutesDBusLogServiceActionsClear(App& app)
Andrew Geisslercb92c032018-08-17 07:56:14 -07003119{
Andrew Geisslercb92c032018-08-17 07:56:14 -07003120 /**
3121 * Function handles POST method request.
3122 * The Clear Log actions does not require any parameter.The action deletes
3123 * all entries found in the Entries collection for this Log Service.
3124 */
Andrew Geisslercb92c032018-08-17 07:56:14 -07003125
George Liu0fda0f12021-11-16 10:06:17 +08003126 BMCWEB_ROUTE(
3127 app,
3128 "/redfish/v1/Systems/system/LogServices/EventLog/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003129 .privileges(redfish::privileges::postLogService)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003130 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003131 [&app](const crow::Request& req,
3132 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003133 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003134 {
3135 return;
3136 }
3137 BMCWEB_LOG_DEBUG << "Do delete all entries.";
Andrew Geisslercb92c032018-08-17 07:56:14 -07003138
Ed Tanous002d39b2022-05-31 08:59:27 -07003139 // Process response from Logging service.
3140 auto respHandler = [asyncResp](const boost::system::error_code ec) {
3141 BMCWEB_LOG_DEBUG << "doClearLog resp_handler callback: Done";
3142 if (ec)
3143 {
3144 // TODO Handle for specific error code
3145 BMCWEB_LOG_ERROR << "doClearLog resp_handler got error " << ec;
3146 asyncResp->res.result(
3147 boost::beast::http::status::internal_server_error);
3148 return;
3149 }
Andrew Geisslercb92c032018-08-17 07:56:14 -07003150
Ed Tanous002d39b2022-05-31 08:59:27 -07003151 asyncResp->res.result(boost::beast::http::status::no_content);
3152 };
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003153
Ed Tanous002d39b2022-05-31 08:59:27 -07003154 // Make call to Logging service to request Clear Log
3155 crow::connections::systemBus->async_method_call(
3156 respHandler, "xyz.openbmc_project.Logging",
3157 "/xyz/openbmc_project/logging",
3158 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3159 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003160}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003161
3162/****************************************************
3163 * Redfish PostCode interfaces
3164 * using DBUS interface: getPostCodesTS
3165 ******************************************************/
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003166inline void requestRoutesPostCodesLogService(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003167{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003168 BMCWEB_ROUTE(app, "/redfish/v1/Systems/system/LogServices/PostCodes/")
Ed Tanoused398212021-06-09 17:05:54 -07003169 .privileges(redfish::privileges::getLogService)
Ed Tanous002d39b2022-05-31 08:59:27 -07003170 .methods(boost::beast::http::verb::get)(
3171 [&app](const crow::Request& req,
3172 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003173 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003174 {
3175 return;
3176 }
Ed Tanous14766872022-03-15 10:44:42 -07003177
Ed Tanous002d39b2022-05-31 08:59:27 -07003178 asyncResp->res.jsonValue["@odata.id"] =
3179 "/redfish/v1/Systems/system/LogServices/PostCodes";
3180 asyncResp->res.jsonValue["@odata.type"] =
3181 "#LogService.v1_1_0.LogService";
3182 asyncResp->res.jsonValue["Name"] = "POST Code Log Service";
3183 asyncResp->res.jsonValue["Description"] = "POST Code Log Service";
3184 asyncResp->res.jsonValue["Id"] = "BIOS POST Code Log";
3185 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
3186 asyncResp->res.jsonValue["Entries"]["@odata.id"] =
3187 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
Tejas Patil7c8c4052021-06-04 17:43:14 +05303188
Ed Tanous002d39b2022-05-31 08:59:27 -07003189 std::pair<std::string, std::string> redfishDateTimeOffset =
3190 crow::utility::getDateTimeOffsetNow();
3191 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
3192 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
3193 redfishDateTimeOffset.second;
Tejas Patil7c8c4052021-06-04 17:43:14 +05303194
Ed Tanous002d39b2022-05-31 08:59:27 -07003195 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
3196 {"target",
3197 "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/LogService.ClearLog"}};
George Liu0fda0f12021-11-16 10:06:17 +08003198 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003199}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003200
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003201inline void requestRoutesPostCodesClear(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003202{
George Liu0fda0f12021-11-16 10:06:17 +08003203 BMCWEB_ROUTE(
3204 app,
3205 "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/LogService.ClearLog/")
Ed Tanoused398212021-06-09 17:05:54 -07003206 // The following privilege is incorrect; It should be ConfigureManager
3207 //.privileges(redfish::privileges::postLogService)
Ed Tanous432a8902021-06-14 15:28:56 -07003208 .privileges({{"ConfigureComponents"}})
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003209 .methods(boost::beast::http::verb::post)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003210 [&app](const crow::Request& req,
3211 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003212 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003213 {
3214 return;
3215 }
3216 BMCWEB_LOG_DEBUG << "Do delete all postcodes entries.";
ZhikuiRena3316fc2020-01-29 14:58:08 -08003217
Ed Tanous002d39b2022-05-31 08:59:27 -07003218 // Make call to post-code service to request clear all
3219 crow::connections::systemBus->async_method_call(
3220 [asyncResp](const boost::system::error_code ec) {
3221 if (ec)
3222 {
3223 // TODO Handle for specific error code
3224 BMCWEB_LOG_ERROR << "doClearPostCodes resp_handler got error "
3225 << ec;
3226 asyncResp->res.result(
3227 boost::beast::http::status::internal_server_error);
3228 messages::internalError(asyncResp->res);
3229 return;
3230 }
3231 },
3232 "xyz.openbmc_project.State.Boot.PostCode0",
3233 "/xyz/openbmc_project/State/Boot/PostCode0",
3234 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3235 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003236}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003237
3238static void fillPostCodeEntry(
zhanghch058d1b46d2021-04-01 11:18:24 +08003239 const std::shared_ptr<bmcweb::AsyncResp>& aResp,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303240 const boost::container::flat_map<
3241 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>& postcode,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003242 const uint16_t bootIndex, const uint64_t codeIndex = 0,
3243 const uint64_t skip = 0, const uint64_t top = 0)
3244{
3245 // Get the Message from the MessageRegistry
Ed Tanousfffb8c12022-02-07 23:53:03 -08003246 const registries::Message* message =
3247 registries::getMessage("OpenBMC.0.2.BIOSPOSTCode");
ZhikuiRena3316fc2020-01-29 14:58:08 -08003248
3249 uint64_t currentCodeIndex = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003250 nlohmann::json& logEntryArray = aResp->res.jsonValue["Members"];
ZhikuiRena3316fc2020-01-29 14:58:08 -08003251
3252 uint64_t firstCodeTimeUs = 0;
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303253 for (const std::pair<uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3254 code : postcode)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003255 {
3256 currentCodeIndex++;
3257 std::string postcodeEntryID =
3258 "B" + std::to_string(bootIndex) + "-" +
3259 std::to_string(currentCodeIndex); // 1 based index in EntryID string
3260
3261 uint64_t usecSinceEpoch = code.first;
3262 uint64_t usTimeOffset = 0;
3263
3264 if (1 == currentCodeIndex)
3265 { // already incremented
3266 firstCodeTimeUs = code.first;
3267 }
3268 else
3269 {
3270 usTimeOffset = code.first - firstCodeTimeUs;
3271 }
3272
3273 // skip if no specific codeIndex is specified and currentCodeIndex does
3274 // not fall between top and skip
3275 if ((codeIndex == 0) &&
3276 (currentCodeIndex <= skip || currentCodeIndex > top))
3277 {
3278 continue;
3279 }
3280
Gunnar Mills4e0453b2020-07-08 14:00:30 -05003281 // skip if a specific codeIndex is specified and does not match the
ZhikuiRena3316fc2020-01-29 14:58:08 -08003282 // currentIndex
3283 if ((codeIndex > 0) && (currentCodeIndex != codeIndex))
3284 {
3285 // This is done for simplicity. 1st entry is needed to calculate
3286 // time offset. To improve efficiency, one can get to the entry
3287 // directly (possibly with flatmap's nth method)
3288 continue;
3289 }
3290
3291 // currentCodeIndex is within top and skip or equal to specified code
3292 // index
3293
3294 // Get the Created time from the timestamp
3295 std::string entryTimeStr;
Nan Zhou1d8782e2021-11-29 22:23:18 -08003296 entryTimeStr =
3297 crow::utility::getDateTimeUint(usecSinceEpoch / 1000 / 1000);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003298
3299 // assemble messageArgs: BootIndex, TimeOffset(100us), PostCode(hex)
3300 std::ostringstream hexCode;
3301 hexCode << "0x" << std::setfill('0') << std::setw(2) << std::hex
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303302 << std::get<0>(code.second);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003303 std::ostringstream timeOffsetStr;
3304 // Set Fixed -Point Notation
3305 timeOffsetStr << std::fixed;
3306 // Set precision to 4 digits
3307 timeOffsetStr << std::setprecision(4);
3308 // Add double to stream
3309 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000;
3310 std::vector<std::string> messageArgs = {
3311 std::to_string(bootIndex), timeOffsetStr.str(), hexCode.str()};
3312
3313 // Get MessageArgs template from message registry
3314 std::string msg;
3315 if (message != nullptr)
3316 {
3317 msg = message->message;
3318
3319 // fill in this post code value
3320 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003321 for (const std::string& messageArg : messageArgs)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003322 {
3323 std::string argStr = "%" + std::to_string(++i);
3324 size_t argPos = msg.find(argStr);
3325 if (argPos != std::string::npos)
3326 {
3327 msg.replace(argPos, argStr.length(), messageArg);
3328 }
3329 }
3330 }
3331
Tim Leed4342a92020-04-27 11:47:58 +08003332 // Get Severity template from message registry
3333 std::string severity;
3334 if (message != nullptr)
3335 {
Ed Tanous5f2b84e2022-02-08 00:41:53 -08003336 severity = message->messageSeverity;
Tim Leed4342a92020-04-27 11:47:58 +08003337 }
3338
ZhikuiRena3316fc2020-01-29 14:58:08 -08003339 // add to AsyncResp
3340 logEntryArray.push_back({});
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003341 nlohmann::json& bmcLogEntry = logEntryArray.back();
Jason M. Bills84afc482022-06-24 12:38:23 -07003342 bmcLogEntry["@odata.type"] = "#LogEntry.v1_8_0.LogEntry";
3343 bmcLogEntry["@odata.id"] =
3344 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/" +
3345 postcodeEntryID;
3346 bmcLogEntry["Name"] = "POST Code Log Entry";
3347 bmcLogEntry["Id"] = postcodeEntryID;
3348 bmcLogEntry["Message"] = std::move(msg);
3349 bmcLogEntry["MessageId"] = "OpenBMC.0.2.BIOSPOSTCode";
3350 bmcLogEntry["MessageArgs"] = std::move(messageArgs);
3351 bmcLogEntry["EntryType"] = "Event";
3352 bmcLogEntry["Severity"] = std::move(severity);
3353 bmcLogEntry["Created"] = entryTimeStr;
George Liu647b3cd2021-07-05 12:43:56 +08003354 if (!std::get<std::vector<uint8_t>>(code.second).empty())
3355 {
3356 bmcLogEntry["AdditionalDataURI"] =
3357 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/" +
3358 postcodeEntryID + "/attachment";
3359 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003360 }
3361}
3362
zhanghch058d1b46d2021-04-01 11:18:24 +08003363static void getPostCodeForEntry(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003364 const uint16_t bootIndex,
3365 const uint64_t codeIndex)
3366{
3367 crow::connections::systemBus->async_method_call(
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303368 [aResp, bootIndex,
3369 codeIndex](const boost::system::error_code ec,
3370 const boost::container::flat_map<
3371 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3372 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003373 if (ec)
3374 {
3375 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
3376 messages::internalError(aResp->res);
3377 return;
3378 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003379
Ed Tanous002d39b2022-05-31 08:59:27 -07003380 // skip the empty postcode boots
3381 if (postcode.empty())
3382 {
3383 return;
3384 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003385
Ed Tanous002d39b2022-05-31 08:59:27 -07003386 fillPostCodeEntry(aResp, postcode, bootIndex, codeIndex);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003387
Ed Tanous002d39b2022-05-31 08:59:27 -07003388 aResp->res.jsonValue["Members@odata.count"] =
3389 aResp->res.jsonValue["Members"].size();
ZhikuiRena3316fc2020-01-29 14:58:08 -08003390 },
Jonathan Doman15124762021-01-07 17:54:17 -08003391 "xyz.openbmc_project.State.Boot.PostCode0",
3392 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08003393 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3394 bootIndex);
3395}
3396
zhanghch058d1b46d2021-04-01 11:18:24 +08003397static void getPostCodeForBoot(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003398 const uint16_t bootIndex,
3399 const uint16_t bootCount,
3400 const uint64_t entryCount, const uint64_t skip,
3401 const uint64_t top)
3402{
3403 crow::connections::systemBus->async_method_call(
3404 [aResp, bootIndex, bootCount, entryCount, skip,
3405 top](const boost::system::error_code ec,
Manojkiran Eda6c9a2792021-02-27 14:25:04 +05303406 const boost::container::flat_map<
3407 uint64_t, std::tuple<uint64_t, std::vector<uint8_t>>>&
3408 postcode) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003409 if (ec)
3410 {
3411 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
3412 messages::internalError(aResp->res);
3413 return;
3414 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003415
Ed Tanous002d39b2022-05-31 08:59:27 -07003416 uint64_t endCount = entryCount;
3417 if (!postcode.empty())
3418 {
3419 endCount = entryCount + postcode.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -08003420
Ed Tanous002d39b2022-05-31 08:59:27 -07003421 if ((skip < endCount) && ((top + skip) > entryCount))
ZhikuiRena3316fc2020-01-29 14:58:08 -08003422 {
Ed Tanous002d39b2022-05-31 08:59:27 -07003423 uint64_t thisBootSkip = std::max(skip, entryCount) - entryCount;
3424 uint64_t thisBootTop =
3425 std::min(top + skip, endCount) - entryCount;
3426
3427 fillPostCodeEntry(aResp, postcode, bootIndex, 0, thisBootSkip,
3428 thisBootTop);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003429 }
Ed Tanous002d39b2022-05-31 08:59:27 -07003430 aResp->res.jsonValue["Members@odata.count"] = endCount;
3431 }
3432
3433 // continue to previous bootIndex
3434 if (bootIndex < bootCount)
3435 {
3436 getPostCodeForBoot(aResp, static_cast<uint16_t>(bootIndex + 1),
3437 bootCount, endCount, skip, top);
3438 }
3439 else
3440 {
3441 aResp->res.jsonValue["Members@odata.nextLink"] =
3442 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries?$skip=" +
3443 std::to_string(skip + top);
3444 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003445 },
Jonathan Doman15124762021-01-07 17:54:17 -08003446 "xyz.openbmc_project.State.Boot.PostCode0",
3447 "/xyz/openbmc_project/State/Boot/PostCode0",
ZhikuiRena3316fc2020-01-29 14:58:08 -08003448 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3449 bootIndex);
3450}
3451
zhanghch058d1b46d2021-04-01 11:18:24 +08003452static void
3453 getCurrentBootNumber(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
3454 const uint64_t skip, const uint64_t top)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003455{
3456 uint64_t entryCount = 0;
Jonathan Doman1e1e5982021-06-11 09:36:17 -07003457 sdbusplus::asio::getProperty<uint16_t>(
3458 *crow::connections::systemBus,
3459 "xyz.openbmc_project.State.Boot.PostCode0",
3460 "/xyz/openbmc_project/State/Boot/PostCode0",
3461 "xyz.openbmc_project.State.Boot.PostCode", "CurrentBootCycleCount",
3462 [aResp, entryCount, skip, top](const boost::system::error_code ec,
3463 const uint16_t bootCount) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003464 if (ec)
3465 {
3466 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
3467 messages::internalError(aResp->res);
3468 return;
3469 }
3470 getPostCodeForBoot(aResp, 1, bootCount, entryCount, skip, top);
Jonathan Doman1e1e5982021-06-11 09:36:17 -07003471 });
ZhikuiRena3316fc2020-01-29 14:58:08 -08003472}
3473
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003474inline void requestRoutesPostCodesEntryCollection(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003475{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003476 BMCWEB_ROUTE(app,
3477 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/")
Ed Tanoused398212021-06-09 17:05:54 -07003478 .privileges(redfish::privileges::getLogEntryCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003479 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003480 [&app](const crow::Request& req,
3481 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
Ed Tanous002d39b2022-05-31 08:59:27 -07003482 query_param::QueryCapabilities capabilities = {
3483 .canDelegateTop = true,
3484 .canDelegateSkip = true,
3485 };
3486 query_param::Query delegatedQuery;
3487 if (!redfish::setUpRedfishRouteWithDelegation(
Carson Labrado3ba00072022-06-06 19:40:56 +00003488 app, req, asyncResp, delegatedQuery, capabilities))
Ed Tanous002d39b2022-05-31 08:59:27 -07003489 {
3490 return;
3491 }
3492 asyncResp->res.jsonValue["@odata.type"] =
3493 "#LogEntryCollection.LogEntryCollection";
3494 asyncResp->res.jsonValue["@odata.id"] =
3495 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
3496 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
3497 asyncResp->res.jsonValue["Description"] =
3498 "Collection of POST Code Log Entries";
3499 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3500 asyncResp->res.jsonValue["Members@odata.count"] = 0;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003501
Ed Tanous002d39b2022-05-31 08:59:27 -07003502 getCurrentBootNumber(asyncResp, delegatedQuery.skip,
3503 delegatedQuery.top);
3504 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003505}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003506
George Liu647b3cd2021-07-05 12:43:56 +08003507/**
3508 * @brief Parse post code ID and get the current value and index value
3509 * eg: postCodeID=B1-2, currentValue=1, index=2
3510 *
3511 * @param[in] postCodeID Post Code ID
3512 * @param[out] currentValue Current value
3513 * @param[out] index Index value
3514 *
3515 * @return bool true if the parsing is successful, false the parsing fails
3516 */
3517inline static bool parsePostCode(const std::string& postCodeID,
3518 uint64_t& currentValue, uint16_t& index)
3519{
3520 std::vector<std::string> split;
3521 boost::algorithm::split(split, postCodeID, boost::is_any_of("-"));
3522 if (split.size() != 2 || split[0].length() < 2 || split[0].front() != 'B')
3523 {
3524 return false;
3525 }
3526
Ed Tanousca45aa32022-01-07 09:28:45 -08003527 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
George Liu647b3cd2021-07-05 12:43:56 +08003528 const char* start = split[0].data() + 1;
Ed Tanousca45aa32022-01-07 09:28:45 -08003529 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
George Liu647b3cd2021-07-05 12:43:56 +08003530 const char* end = split[0].data() + split[0].size();
3531 auto [ptrIndex, ecIndex] = std::from_chars(start, end, index);
3532
3533 if (ptrIndex != end || ecIndex != std::errc())
3534 {
3535 return false;
3536 }
3537
3538 start = split[1].data();
Ed Tanousca45aa32022-01-07 09:28:45 -08003539
3540 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
George Liu647b3cd2021-07-05 12:43:56 +08003541 end = split[1].data() + split[1].size();
3542 auto [ptrValue, ecValue] = std::from_chars(start, end, currentValue);
George Liu647b3cd2021-07-05 12:43:56 +08003543
Tony Lee517d9a52022-06-28 15:41:23 +08003544 return ptrValue == end && ecValue == std::errc();
George Liu647b3cd2021-07-05 12:43:56 +08003545}
3546
3547inline void requestRoutesPostCodesEntryAdditionalData(App& app)
3548{
George Liu0fda0f12021-11-16 10:06:17 +08003549 BMCWEB_ROUTE(
3550 app,
3551 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/<str>/attachment/")
George Liu647b3cd2021-07-05 12:43:56 +08003552 .privileges(redfish::privileges::getLogEntry)
3553 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003554 [&app](const crow::Request& req,
3555 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3556 const std::string& postCodeID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003557 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003558 {
3559 return;
3560 }
3561 if (!http_helpers::isOctetAccepted(req.getHeaderValue("Accept")))
3562 {
3563 asyncResp->res.result(boost::beast::http::status::bad_request);
3564 return;
3565 }
George Liu647b3cd2021-07-05 12:43:56 +08003566
Ed Tanous002d39b2022-05-31 08:59:27 -07003567 uint64_t currentValue = 0;
3568 uint16_t index = 0;
3569 if (!parsePostCode(postCodeID, currentValue, index))
3570 {
3571 messages::resourceNotFound(asyncResp->res, "LogEntry", postCodeID);
3572 return;
3573 }
George Liu647b3cd2021-07-05 12:43:56 +08003574
Ed Tanous002d39b2022-05-31 08:59:27 -07003575 crow::connections::systemBus->async_method_call(
3576 [asyncResp, postCodeID, currentValue](
3577 const boost::system::error_code ec,
3578 const std::vector<std::tuple<uint64_t, std::vector<uint8_t>>>&
3579 postcodes) {
3580 if (ec.value() == EBADR)
3581 {
3582 messages::resourceNotFound(asyncResp->res, "LogEntry",
3583 postCodeID);
3584 return;
3585 }
3586 if (ec)
3587 {
3588 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
3589 messages::internalError(asyncResp->res);
3590 return;
3591 }
George Liu647b3cd2021-07-05 12:43:56 +08003592
Ed Tanous002d39b2022-05-31 08:59:27 -07003593 size_t value = static_cast<size_t>(currentValue) - 1;
3594 if (value == std::string::npos || postcodes.size() < currentValue)
3595 {
3596 BMCWEB_LOG_ERROR << "Wrong currentValue value";
3597 messages::resourceNotFound(asyncResp->res, "LogEntry",
3598 postCodeID);
3599 return;
3600 }
George Liu647b3cd2021-07-05 12:43:56 +08003601
Ed Tanous002d39b2022-05-31 08:59:27 -07003602 const auto& [tID, c] = postcodes[value];
3603 if (c.empty())
3604 {
3605 BMCWEB_LOG_INFO << "No found post code data";
3606 messages::resourceNotFound(asyncResp->res, "LogEntry",
3607 postCodeID);
3608 return;
3609 }
3610 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3611 const char* d = reinterpret_cast<const char*>(c.data());
3612 std::string_view strData(d, c.size());
George Liu647b3cd2021-07-05 12:43:56 +08003613
Ed Tanous002d39b2022-05-31 08:59:27 -07003614 asyncResp->res.addHeader("Content-Type",
3615 "application/octet-stream");
3616 asyncResp->res.addHeader("Content-Transfer-Encoding", "Base64");
3617 asyncResp->res.body() = crow::utility::base64encode(strData);
3618 },
3619 "xyz.openbmc_project.State.Boot.PostCode0",
3620 "/xyz/openbmc_project/State/Boot/PostCode0",
3621 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodes", index);
3622 });
George Liu647b3cd2021-07-05 12:43:56 +08003623}
3624
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003625inline void requestRoutesPostCodesEntry(App& app)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003626{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003627 BMCWEB_ROUTE(
3628 app, "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07003629 .privileges(redfish::privileges::getLogEntry)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003630 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07003631 [&app](const crow::Request& req,
3632 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
3633 const std::string& targetID) {
Carson Labrado3ba00072022-06-06 19:40:56 +00003634 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07003635 {
3636 return;
3637 }
3638 uint16_t bootIndex = 0;
3639 uint64_t codeIndex = 0;
3640 if (!parsePostCode(targetID, codeIndex, bootIndex))
3641 {
3642 // Requested ID was not found
3643 messages::resourceMissingAtURI(asyncResp->res, req.urlView);
3644 return;
3645 }
3646 if (bootIndex == 0 || codeIndex == 0)
3647 {
3648 BMCWEB_LOG_DEBUG << "Get Post Code invalid entry string "
3649 << targetID;
3650 }
ZhikuiRena3316fc2020-01-29 14:58:08 -08003651
Ed Tanous002d39b2022-05-31 08:59:27 -07003652 asyncResp->res.jsonValue["@odata.type"] = "#LogEntry.v1_4_0.LogEntry";
3653 asyncResp->res.jsonValue["@odata.id"] =
3654 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
3655 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
3656 asyncResp->res.jsonValue["Description"] =
3657 "Collection of POST Code Log Entries";
3658 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3659 asyncResp->res.jsonValue["Members@odata.count"] = 0;
ZhikuiRena3316fc2020-01-29 14:58:08 -08003660
Ed Tanous002d39b2022-05-31 08:59:27 -07003661 getPostCodeForEntry(asyncResp, bootIndex, codeIndex);
3662 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07003663}
ZhikuiRena3316fc2020-01-29 14:58:08 -08003664
Ed Tanous1da66f72018-07-27 16:13:37 -07003665} // namespace redfish