blob: 7be934e82b0a56361f988084d4fa4cd2b52dc754 [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
18#include "node.hpp"
Jason M. Bills4851d452019-03-28 11:27:48 -070019#include "registries.hpp"
20#include "registries/base_message_registry.hpp"
21#include "registries/openbmc_message_registry.hpp"
James Feist46229572020-02-19 15:11:58 -080022#include "task.hpp"
Ed Tanous1da66f72018-07-27 16:13:37 -070023
Jason M. Billse1f26342018-07-18 12:12:00 -070024#include <systemd/sd-journal.h>
25
Jason M. Bills4851d452019-03-28 11:27:48 -070026#include <boost/algorithm/string/split.hpp>
27#include <boost/beast/core/span.hpp>
Ed Tanous1da66f72018-07-27 16:13:37 -070028#include <boost/container/flat_map.hpp>
Jason M. Bills1ddcf012019-11-26 14:59:21 -080029#include <boost/system/linux_error.hpp>
raviteja-b06578432020-02-03 12:50:42 -060030#include <dump_offload.hpp>
Andrew Geisslercb92c032018-08-17 07:56:14 -070031#include <error_messages.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050032
James Feist4418c7f2019-04-15 11:09:15 -070033#include <filesystem>
Jason M. Billscd225da2019-05-08 15:31:57 -070034#include <string_view>
Ed Tanousabf2add2019-01-22 16:40:12 -080035#include <variant>
Ed Tanous1da66f72018-07-27 16:13:37 -070036
37namespace redfish
38{
39
Gunnar Mills1214b7e2020-06-04 10:11:30 -050040constexpr char const* crashdumpObject = "com.intel.crashdump";
41constexpr char const* crashdumpPath = "/com/intel/crashdump";
Gunnar Mills1214b7e2020-06-04 10:11:30 -050042constexpr char const* crashdumpInterface = "com.intel.crashdump";
43constexpr char const* deleteAllInterface =
Jason M. Bills5b61b5e2019-10-16 10:59:02 -070044 "xyz.openbmc_project.Collection.DeleteAll";
Gunnar Mills1214b7e2020-06-04 10:11:30 -050045constexpr char const* crashdumpOnDemandInterface =
Jason M. Bills424c4172019-03-21 13:50:33 -070046 "com.intel.crashdump.OnDemand";
Gunnar Mills1214b7e2020-06-04 10:11:30 -050047constexpr char const* crashdumpRawPECIInterface =
Jason M. Bills424c4172019-03-21 13:50:33 -070048 "com.intel.crashdump.SendRawPeci";
Kenny L. Ku6eda7682020-06-19 09:48:36 -070049constexpr char const* crashdumpTelemetryInterface =
50 "com.intel.crashdump.Telemetry";
Ed Tanous1da66f72018-07-27 16:13:37 -070051
Jason M. Bills4851d452019-03-28 11:27:48 -070052namespace message_registries
53{
Gunnar Mills1214b7e2020-06-04 10:11:30 -050054static const Message* getMessageFromRegistry(
55 const std::string& messageKey,
Jason M. Bills4851d452019-03-28 11:27:48 -070056 const boost::beast::span<const MessageEntry> registry)
57{
58 boost::beast::span<const MessageEntry>::const_iterator messageIt =
59 std::find_if(registry.cbegin(), registry.cend(),
Gunnar Mills1214b7e2020-06-04 10:11:30 -050060 [&messageKey](const MessageEntry& messageEntry) {
Jason M. Bills4851d452019-03-28 11:27:48 -070061 return !std::strcmp(messageEntry.first,
62 messageKey.c_str());
63 });
64 if (messageIt != registry.cend())
65 {
66 return &messageIt->second;
67 }
68
69 return nullptr;
70}
71
Gunnar Mills1214b7e2020-06-04 10:11:30 -050072static const Message* getMessage(const std::string_view& messageID)
Jason M. Bills4851d452019-03-28 11:27:48 -070073{
74 // Redfish MessageIds are in the form
75 // RegistryName.MajorVersion.MinorVersion.MessageKey, so parse it to find
76 // the right Message
77 std::vector<std::string> fields;
78 fields.reserve(4);
79 boost::split(fields, messageID, boost::is_any_of("."));
Gunnar Mills1214b7e2020-06-04 10:11:30 -050080 std::string& registryName = fields[0];
81 std::string& messageKey = fields[3];
Jason M. Bills4851d452019-03-28 11:27:48 -070082
83 // Find the right registry and check it for the MessageKey
84 if (std::string(base::header.registryPrefix) == registryName)
85 {
86 return getMessageFromRegistry(
87 messageKey, boost::beast::span<const MessageEntry>(base::registry));
88 }
89 if (std::string(openbmc::header.registryPrefix) == registryName)
90 {
91 return getMessageFromRegistry(
92 messageKey,
93 boost::beast::span<const MessageEntry>(openbmc::registry));
94 }
95 return nullptr;
96}
97} // namespace message_registries
98
James Feistf6150402019-01-08 10:36:20 -080099namespace fs = std::filesystem;
Ed Tanous1da66f72018-07-27 16:13:37 -0700100
Andrew Geisslercb92c032018-08-17 07:56:14 -0700101using GetManagedPropertyType = boost::container::flat_map<
Patrick Williams19bd78d2020-05-13 17:38:24 -0500102 std::string, std::variant<std::string, bool, uint8_t, int16_t, uint16_t,
103 int32_t, uint32_t, int64_t, uint64_t, double>>;
Andrew Geisslercb92c032018-08-17 07:56:14 -0700104
105using GetManagedObjectsType = boost::container::flat_map<
106 sdbusplus::message::object_path,
107 boost::container::flat_map<std::string, GetManagedPropertyType>>;
108
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500109inline std::string translateSeverityDbusToRedfish(const std::string& s)
Andrew Geisslercb92c032018-08-17 07:56:14 -0700110{
111 if (s == "xyz.openbmc_project.Logging.Entry.Level.Alert")
112 {
113 return "Critical";
114 }
115 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Critical")
116 {
117 return "Critical";
118 }
119 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Debug")
120 {
121 return "OK";
122 }
123 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Emergency")
124 {
125 return "Critical";
126 }
127 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Error")
128 {
129 return "Critical";
130 }
131 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Informational")
132 {
133 return "OK";
134 }
135 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Notice")
136 {
137 return "OK";
138 }
139 else if (s == "xyz.openbmc_project.Logging.Entry.Level.Warning")
140 {
141 return "Warning";
142 }
143 return "";
144}
145
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500146static int getJournalMetadata(sd_journal* journal,
147 const std::string_view& field,
148 std::string_view& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700149{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500150 const char* data = nullptr;
Jason M. Bills16428a12018-11-02 12:42:29 -0700151 size_t length = 0;
152 int ret = 0;
153 // Get the metadata from the requested field of the journal entry
Ed Tanous271584a2019-07-09 16:24:22 -0700154 ret = sd_journal_get_data(journal, field.data(),
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500155 reinterpret_cast<const void**>(&data), &length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700156 if (ret < 0)
157 {
158 return ret;
159 }
Ed Tanous39e77502019-03-04 17:35:53 -0800160 contents = std::string_view(data, length);
Jason M. Bills16428a12018-11-02 12:42:29 -0700161 // Only use the content after the "=" character.
162 contents.remove_prefix(std::min(contents.find("=") + 1, contents.size()));
163 return ret;
164}
165
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500166static int getJournalMetadata(sd_journal* journal,
167 const std::string_view& field, const int& base,
168 long int& contents)
Jason M. Bills16428a12018-11-02 12:42:29 -0700169{
170 int ret = 0;
Ed Tanous39e77502019-03-04 17:35:53 -0800171 std::string_view metadata;
Jason M. Bills16428a12018-11-02 12:42:29 -0700172 // Get the metadata from the requested field of the journal entry
173 ret = getJournalMetadata(journal, field, metadata);
174 if (ret < 0)
175 {
176 return ret;
177 }
Ed Tanousb01bf292019-03-25 19:25:26 +0000178 contents = strtol(metadata.data(), nullptr, base);
Jason M. Bills16428a12018-11-02 12:42:29 -0700179 return ret;
180}
181
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500182static bool getEntryTimestamp(sd_journal* journal, std::string& entryTimestamp)
ZhikuiRena3316fc2020-01-29 14:58:08 -0800183{
184 int ret = 0;
185 uint64_t timestamp = 0;
186 ret = sd_journal_get_realtime_usec(journal, &timestamp);
187 if (ret < 0)
188 {
189 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
190 << strerror(-ret);
191 return false;
192 }
Asmitha Karunanithi9c620e22020-08-02 11:55:21 -0500193 entryTimestamp = crow::utility::getDateTime(
194 static_cast<std::time_t>(timestamp / 1000 / 1000));
195 return true;
ZhikuiRena3316fc2020-01-29 14:58:08 -0800196}
197
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500198static bool getSkipParam(crow::Response& res, const crow::Request& req,
199 uint64_t& skip)
Jason M. Bills16428a12018-11-02 12:42:29 -0700200{
James Feist5a7e8772020-07-22 09:08:38 -0700201 boost::urls::url_view::params_type::iterator it =
202 req.urlParams.find("$skip");
203 if (it != req.urlParams.end())
Jason M. Bills16428a12018-11-02 12:42:29 -0700204 {
James Feist5a7e8772020-07-22 09:08:38 -0700205 std::string skipParam = it->value();
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500206 char* ptr = nullptr;
James Feist5a7e8772020-07-22 09:08:38 -0700207 skip = std::strtoul(skipParam.c_str(), &ptr, 10);
208 if (skipParam.empty() || *ptr != '\0')
Jason M. Bills16428a12018-11-02 12:42:29 -0700209 {
210
211 messages::queryParameterValueTypeError(res, std::string(skipParam),
212 "$skip");
213 return false;
214 }
Jason M. Bills16428a12018-11-02 12:42:29 -0700215 }
216 return true;
217}
218
Ed Tanous271584a2019-07-09 16:24:22 -0700219static constexpr const uint64_t maxEntriesPerPage = 1000;
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500220static bool getTopParam(crow::Response& res, const crow::Request& req,
221 uint64_t& top)
Jason M. Bills16428a12018-11-02 12:42:29 -0700222{
James Feist5a7e8772020-07-22 09:08:38 -0700223 boost::urls::url_view::params_type::iterator it =
224 req.urlParams.find("$top");
225 if (it != req.urlParams.end())
Jason M. Bills16428a12018-11-02 12:42:29 -0700226 {
James Feist5a7e8772020-07-22 09:08:38 -0700227 std::string topParam = it->value();
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500228 char* ptr = nullptr;
James Feist5a7e8772020-07-22 09:08:38 -0700229 top = std::strtoul(topParam.c_str(), &ptr, 10);
230 if (topParam.empty() || *ptr != '\0')
Jason M. Bills16428a12018-11-02 12:42:29 -0700231 {
232 messages::queryParameterValueTypeError(res, std::string(topParam),
233 "$top");
234 return false;
235 }
Ed Tanous271584a2019-07-09 16:24:22 -0700236 if (top < 1U || top > maxEntriesPerPage)
Jason M. Bills16428a12018-11-02 12:42:29 -0700237 {
238
239 messages::queryParameterOutOfRange(
240 res, std::to_string(top), "$top",
241 "1-" + std::to_string(maxEntriesPerPage));
242 return false;
243 }
244 }
245 return true;
246}
247
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500248static bool getUniqueEntryID(sd_journal* journal, std::string& entryID,
Jason M. Billse85d6b12019-07-29 17:01:15 -0700249 const bool firstEntry = true)
Jason M. Bills16428a12018-11-02 12:42:29 -0700250{
251 int ret = 0;
252 static uint64_t prevTs = 0;
253 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700254 if (firstEntry)
255 {
256 prevTs = 0;
257 }
258
Jason M. Bills16428a12018-11-02 12:42:29 -0700259 // Get the entry timestamp
260 uint64_t curTs = 0;
261 ret = sd_journal_get_realtime_usec(journal, &curTs);
262 if (ret < 0)
263 {
264 BMCWEB_LOG_ERROR << "Failed to read entry timestamp: "
265 << strerror(-ret);
266 return false;
267 }
268 // If the timestamp isn't unique, increment the index
269 if (curTs == prevTs)
270 {
271 index++;
272 }
273 else
274 {
275 // Otherwise, reset it
276 index = 0;
277 }
278 // Save the timestamp
279 prevTs = curTs;
280
281 entryID = std::to_string(curTs);
282 if (index > 0)
283 {
284 entryID += "_" + std::to_string(index);
285 }
286 return true;
287}
288
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500289static bool getUniqueEntryID(const std::string& logEntry, std::string& entryID,
Jason M. Billse85d6b12019-07-29 17:01:15 -0700290 const bool firstEntry = true)
Jason M. Bills95820182019-04-22 16:25:34 -0700291{
Ed Tanous271584a2019-07-09 16:24:22 -0700292 static time_t prevTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700293 static int index = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -0700294 if (firstEntry)
295 {
296 prevTs = 0;
297 }
298
Jason M. Bills95820182019-04-22 16:25:34 -0700299 // Get the entry timestamp
Ed Tanous271584a2019-07-09 16:24:22 -0700300 std::time_t curTs = 0;
Jason M. Bills95820182019-04-22 16:25:34 -0700301 std::tm timeStruct = {};
302 std::istringstream entryStream(logEntry);
303 if (entryStream >> std::get_time(&timeStruct, "%Y-%m-%dT%H:%M:%S"))
304 {
305 curTs = std::mktime(&timeStruct);
306 }
307 // If the timestamp isn't unique, increment the index
308 if (curTs == prevTs)
309 {
310 index++;
311 }
312 else
313 {
314 // Otherwise, reset it
315 index = 0;
316 }
317 // Save the timestamp
318 prevTs = curTs;
319
320 entryID = std::to_string(curTs);
321 if (index > 0)
322 {
323 entryID += "_" + std::to_string(index);
324 }
325 return true;
326}
327
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500328static bool getTimestampFromID(crow::Response& res, const std::string& entryID,
329 uint64_t& timestamp, uint64_t& index)
Jason M. Bills16428a12018-11-02 12:42:29 -0700330{
331 if (entryID.empty())
332 {
333 return false;
334 }
335 // Convert the unique ID back to a timestamp to find the entry
Ed Tanous39e77502019-03-04 17:35:53 -0800336 std::string_view tsStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700337
338 auto underscorePos = tsStr.find("_");
339 if (underscorePos != tsStr.npos)
340 {
341 // Timestamp has an index
342 tsStr.remove_suffix(tsStr.size() - underscorePos);
Ed Tanous39e77502019-03-04 17:35:53 -0800343 std::string_view indexStr(entryID);
Jason M. Bills16428a12018-11-02 12:42:29 -0700344 indexStr.remove_prefix(underscorePos + 1);
345 std::size_t pos;
346 try
347 {
Ed Tanous39e77502019-03-04 17:35:53 -0800348 index = std::stoul(std::string(indexStr), &pos);
Jason M. Bills16428a12018-11-02 12:42:29 -0700349 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500350 catch (std::invalid_argument&)
Jason M. Bills16428a12018-11-02 12:42:29 -0700351 {
352 messages::resourceMissingAtURI(res, entryID);
353 return false;
354 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500355 catch (std::out_of_range&)
Jason M. Bills16428a12018-11-02 12:42:29 -0700356 {
357 messages::resourceMissingAtURI(res, entryID);
358 return false;
359 }
360 if (pos != indexStr.size())
361 {
362 messages::resourceMissingAtURI(res, entryID);
363 return false;
364 }
365 }
366 // Timestamp has no index
367 std::size_t pos;
368 try
369 {
Ed Tanous39e77502019-03-04 17:35:53 -0800370 timestamp = std::stoull(std::string(tsStr), &pos);
Jason M. Bills16428a12018-11-02 12:42:29 -0700371 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500372 catch (std::invalid_argument&)
Jason M. Bills16428a12018-11-02 12:42:29 -0700373 {
374 messages::resourceMissingAtURI(res, entryID);
375 return false;
376 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500377 catch (std::out_of_range&)
Jason M. Bills16428a12018-11-02 12:42:29 -0700378 {
379 messages::resourceMissingAtURI(res, entryID);
380 return false;
381 }
382 if (pos != tsStr.size())
383 {
384 messages::resourceMissingAtURI(res, entryID);
385 return false;
386 }
387 return true;
388}
389
Jason M. Bills95820182019-04-22 16:25:34 -0700390static bool
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500391 getRedfishLogFiles(std::vector<std::filesystem::path>& redfishLogFiles)
Jason M. Bills95820182019-04-22 16:25:34 -0700392{
393 static const std::filesystem::path redfishLogDir = "/var/log";
394 static const std::string redfishLogFilename = "redfish";
395
396 // Loop through the directory looking for redfish log files
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500397 for (const std::filesystem::directory_entry& dirEnt :
Jason M. Bills95820182019-04-22 16:25:34 -0700398 std::filesystem::directory_iterator(redfishLogDir))
399 {
400 // If we find a redfish log file, save the path
401 std::string filename = dirEnt.path().filename();
402 if (boost::starts_with(filename, redfishLogFilename))
403 {
404 redfishLogFiles.emplace_back(redfishLogDir / filename);
405 }
406 }
407 // As the log files rotate, they are appended with a ".#" that is higher for
408 // the older logs. Since we don't expect more than 10 log files, we
409 // can just sort the list to get them in order from newest to oldest
410 std::sort(redfishLogFiles.begin(), redfishLogFiles.end());
411
412 return !redfishLogFiles.empty();
413}
414
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500415inline void getDumpEntryCollection(std::shared_ptr<AsyncResp>& asyncResp,
416 const std::string& dumpType)
417{
418 std::string dumpPath;
419 if (dumpType == "BMC")
420 {
421 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
422 }
423 else if (dumpType == "System")
424 {
425 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
426 }
427 else
428 {
429 BMCWEB_LOG_ERROR << "Invalid dump type" << dumpType;
430 messages::internalError(asyncResp->res);
431 return;
432 }
433
434 crow::connections::systemBus->async_method_call(
435 [asyncResp, dumpPath, dumpType](const boost::system::error_code ec,
436 GetManagedObjectsType& resp) {
437 if (ec)
438 {
439 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
440 messages::internalError(asyncResp->res);
441 return;
442 }
443
444 nlohmann::json& entriesArray = asyncResp->res.jsonValue["Members"];
445 entriesArray = nlohmann::json::array();
446
447 for (auto& object : resp)
448 {
449 bool foundDumpEntry = false;
450 for (auto& interfaceMap : object.second)
451 {
452 if (interfaceMap.first ==
453 ("xyz.openbmc_project.Dump.Entry." + dumpType))
454 {
455 foundDumpEntry = true;
456 break;
457 }
458 }
459
460 if (foundDumpEntry == false)
461 {
462 continue;
463 }
464 std::time_t timestamp;
465 uint64_t size = 0;
466 entriesArray.push_back({});
467 nlohmann::json& thisEntry = entriesArray.back();
468 const std::string& path =
469 static_cast<const std::string&>(object.first);
470 std::size_t lastPos = path.rfind("/");
471 if (lastPos == std::string::npos)
472 {
473 continue;
474 }
475 std::string entryID = path.substr(lastPos + 1);
476
477 for (auto& interfaceMap : object.second)
478 {
479 if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
480 {
481
482 for (auto& propertyMap : interfaceMap.second)
483 {
484 if (propertyMap.first == "Size")
485 {
486 auto sizePtr =
487 std::get_if<uint64_t>(&propertyMap.second);
488 if (sizePtr == nullptr)
489 {
490 messages::internalError(asyncResp->res);
491 break;
492 }
493 size = *sizePtr;
494 break;
495 }
496 }
497 }
498 else if (interfaceMap.first ==
499 "xyz.openbmc_project.Time.EpochTime")
500 {
501
502 for (auto& propertyMap : interfaceMap.second)
503 {
504 if (propertyMap.first == "Elapsed")
505 {
506 const uint64_t* usecsTimeStamp =
507 std::get_if<uint64_t>(&propertyMap.second);
508 if (usecsTimeStamp == nullptr)
509 {
510 messages::internalError(asyncResp->res);
511 break;
512 }
513 timestamp =
514 static_cast<std::time_t>(*usecsTimeStamp);
515 break;
516 }
517 }
518 }
519 }
520
521 thisEntry["@odata.type"] = "#LogEntry.v1_5_1.LogEntry";
522 thisEntry["@odata.id"] = dumpPath + entryID;
523 thisEntry["Id"] = entryID;
524 thisEntry["EntryType"] = "Event";
525 thisEntry["Created"] = crow::utility::getDateTime(timestamp);
526 thisEntry["Name"] = dumpType + " Dump Entry";
527
528 thisEntry["Oem"]["OpenBmc"]["@odata.type"] =
529 "#OemLogEntry.v1_0_0.OpenBmc";
530 thisEntry["Oem"]["OpenBmc"]["AdditionalDataSizeBytes"] = size;
531
532 if (dumpType == "BMC")
533 {
534 thisEntry["Oem"]["OpenBmc"]["DiagnosticDataType"] =
535 "Manager";
536 thisEntry["Oem"]["OpenBmc"]["AdditionalDataURI"] =
537 "/redfish/v1/Managers/bmc/LogServices/Dump/"
538 "attachment/" +
539 entryID;
540 }
541 else if (dumpType == "System")
542 {
543 thisEntry["Oem"]["OpenBmc"]["DiagnosticDataType"] = "OEM";
544 thisEntry["Oem"]["OpenBmc"]["OEMDiagnosticDataType"] =
545 "System";
546 thisEntry["Oem"]["OpenBmc"]["AdditionalDataURI"] =
547 "/redfish/v1/Systems/system/LogServices/Dump/"
548 "attachment/" +
549 entryID;
550 }
551 }
552 asyncResp->res.jsonValue["Members@odata.count"] =
553 entriesArray.size();
554 },
555 "xyz.openbmc_project.Dump.Manager", "/xyz/openbmc_project/dump",
556 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
557}
558
559inline void getDumpEntryById(std::shared_ptr<AsyncResp>& asyncResp,
560 const std::string& entryID,
561 const std::string& dumpType)
562{
563 std::string dumpPath;
564 if (dumpType == "BMC")
565 {
566 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
567 }
568 else if (dumpType == "System")
569 {
570 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
571 }
572 else
573 {
574 BMCWEB_LOG_ERROR << "Invalid dump type" << dumpType;
575 messages::internalError(asyncResp->res);
576 return;
577 }
578
579 crow::connections::systemBus->async_method_call(
580 [asyncResp, entryID, dumpPath, dumpType](
581 const boost::system::error_code ec, GetManagedObjectsType& resp) {
582 if (ec)
583 {
584 BMCWEB_LOG_ERROR << "DumpEntry resp_handler got error " << ec;
585 messages::internalError(asyncResp->res);
586 return;
587 }
588
589 for (auto& objectPath : resp)
590 {
591 if (objectPath.first.str.find(
592 "/xyz/openbmc_project/dump/entry/" + entryID) ==
593 std::string::npos)
594 {
595 continue;
596 }
597
598 bool foundDumpEntry = false;
599 for (auto& interfaceMap : objectPath.second)
600 {
601 if (interfaceMap.first ==
602 ("xyz.openbmc_project.Dump.Entry." + dumpType))
603 {
604 foundDumpEntry = true;
605 break;
606 }
607 }
608 if (foundDumpEntry == false)
609 {
610 BMCWEB_LOG_ERROR << "Can't find Dump Entry";
611 messages::internalError(asyncResp->res);
612 return;
613 }
614
615 std::time_t timestamp;
616 uint64_t size = 0;
617
618 for (auto& interfaceMap : objectPath.second)
619 {
620 if (interfaceMap.first == "xyz.openbmc_project.Dump.Entry")
621 {
622 for (auto& propertyMap : interfaceMap.second)
623 {
624 if (propertyMap.first == "Size")
625 {
626 auto sizePtr =
627 std::get_if<uint64_t>(&propertyMap.second);
628 if (sizePtr == nullptr)
629 {
630 messages::internalError(asyncResp->res);
631 break;
632 }
633 size = *sizePtr;
634 break;
635 }
636 }
637 }
638 else if (interfaceMap.first ==
639 "xyz.openbmc_project.Time.EpochTime")
640 {
641 for (auto& propertyMap : interfaceMap.second)
642 {
643 if (propertyMap.first == "Elapsed")
644 {
645 const uint64_t* usecsTimeStamp =
646 std::get_if<uint64_t>(&propertyMap.second);
647 if (usecsTimeStamp == nullptr)
648 {
649 messages::internalError(asyncResp->res);
650 break;
651 }
652 timestamp =
653 static_cast<std::time_t>(*usecsTimeStamp);
654 break;
655 }
656 }
657 }
658 }
659
660 asyncResp->res.jsonValue["@odata.type"] =
661 "#LogEntry.v1_5_1.LogEntry";
662 asyncResp->res.jsonValue["@odata.id"] = dumpPath + entryID;
663 asyncResp->res.jsonValue["Id"] = entryID;
664 asyncResp->res.jsonValue["EntryType"] = "Event";
665 asyncResp->res.jsonValue["Created"] =
666 crow::utility::getDateTime(timestamp);
667 asyncResp->res.jsonValue["Name"] = dumpType + " Dump Entry";
668
669 asyncResp->res.jsonValue["Oem"]["OpenBmc"]["@odata.type"] =
670 "#OemLogEntry.v1_0_0.OpenBmc";
671 asyncResp->res
672 .jsonValue["Oem"]["OpenBmc"]["AdditionalDataSizeBytes"] =
673 size;
674
675 if (dumpType == "BMC")
676 {
677 asyncResp->res
678 .jsonValue["Oem"]["OpenBmc"]["DiagnosticDataType"] =
679 "Manager";
680 asyncResp->res
681 .jsonValue["Oem"]["OpenBmc"]["AdditionalDataURI"] =
682 "/redfish/v1/Managers/bmc/LogServices/Dump/"
683 "attachment/" +
684 entryID;
685 }
686 else if (dumpType == "System")
687 {
688 asyncResp->res
689 .jsonValue["Oem"]["OpenBmc"]["DiagnosticDataType"] =
690 "OEM";
691 asyncResp->res
692 .jsonValue["Oem"]["OpenBmc"]["OEMDiagnosticDataType"] =
693 "System";
694 asyncResp->res
695 .jsonValue["Oem"]["OpenBmc"]["AdditionalDataURI"] =
696 "/redfish/v1/Systems/system/LogServices/Dump/"
697 "attachment/" +
698 entryID;
699 }
700 }
701 },
702 "xyz.openbmc_project.Dump.Manager", "/xyz/openbmc_project/dump",
703 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
704}
705
706inline void deleteDumpEntry(crow::Response& res, const std::string& entryID)
707{
708 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
709
710 auto respHandler = [asyncResp](const boost::system::error_code ec) {
711 BMCWEB_LOG_DEBUG << "Dump Entry doDelete callback: Done";
712 if (ec)
713 {
714 BMCWEB_LOG_ERROR << "Dump (DBus) doDelete respHandler got error "
715 << ec;
716 messages::internalError(asyncResp->res);
717 return;
718 }
719 };
720 crow::connections::systemBus->async_method_call(
721 respHandler, "xyz.openbmc_project.Dump.Manager",
722 "/xyz/openbmc_project/dump/entry/" + entryID,
723 "xyz.openbmc_project.Object.Delete", "Delete");
724}
725
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500726inline void createDumpTaskCallback(const crow::Request& req,
727 std::shared_ptr<AsyncResp> asyncResp,
728 const uint32_t& dumpId,
729 const std::string& dumpPath,
730 const std::string& dumpType)
731{
732 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
Ed Tanouscb13a392020-07-25 19:02:03 +0000733 [dumpId, dumpPath, dumpType, asyncResp](
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500734 boost::system::error_code err, sdbusplus::message::message& m,
735 const std::shared_ptr<task::TaskData>& taskData) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000736 if (err)
737 {
738 messages::internalError(asyncResp->res);
739 return false;
740 }
Asmitha Karunanithia43be802020-05-07 05:05:36 -0500741 std::vector<std::pair<
742 std::string,
743 std::vector<std::pair<std::string, std::variant<std::string>>>>>
744 interfacesList;
745
746 sdbusplus::message::object_path objPath;
747
748 m.read(objPath, interfacesList);
749
750 for (auto& interface : interfacesList)
751 {
752 if (interface.first ==
753 ("xyz.openbmc_project.Dump.Entry." + dumpType))
754 {
755 nlohmann::json retMessage = messages::success();
756 taskData->messages.emplace_back(retMessage);
757
758 std::string headerLoc =
759 "Location: " + dumpPath + std::to_string(dumpId);
760 taskData->payload->httpHeaders.emplace_back(
761 std::move(headerLoc));
762
763 taskData->state = "Completed";
764 return task::completed;
765 }
766 }
767 return !task::completed;
768 },
769 "type='signal',interface='org.freedesktop.DBus."
770 "ObjectManager',"
771 "member='InterfacesAdded', "
772 "path='/xyz/openbmc_project/dump'");
773
774 task->startTimer(std::chrono::minutes(3));
775 task->populateResp(asyncResp->res);
776 task->payload.emplace(req);
777}
778
779inline void createDump(crow::Response& res, const crow::Request& req,
780 const std::string& dumpType)
781{
782 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
783
784 std::string dumpPath;
785 if (dumpType == "BMC")
786 {
787 dumpPath = "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/";
788 }
789 else if (dumpType == "System")
790 {
791 dumpPath = "/redfish/v1/Systems/system/LogServices/Dump/Entries/";
792 }
793 else
794 {
795 BMCWEB_LOG_ERROR << "Invalid dump type: " << dumpType;
796 messages::internalError(asyncResp->res);
797 return;
798 }
799
800 std::optional<std::string> diagnosticDataType;
801 std::optional<std::string> oemDiagnosticDataType;
802
803 if (!redfish::json_util::readJson(
804 req, asyncResp->res, "DiagnosticDataType", diagnosticDataType,
805 "OEMDiagnosticDataType", oemDiagnosticDataType))
806 {
807 return;
808 }
809
810 if (dumpType == "System")
811 {
812 if (!oemDiagnosticDataType || !diagnosticDataType)
813 {
814 BMCWEB_LOG_ERROR << "CreateDump action parameter "
815 "'DiagnosticDataType'/"
816 "'OEMDiagnosticDataType' value not found!";
817 messages::actionParameterMissing(
818 asyncResp->res, "CollectDiagnosticData",
819 "DiagnosticDataType & OEMDiagnosticDataType");
820 return;
821 }
822 else if ((*oemDiagnosticDataType != "System") ||
823 (*diagnosticDataType != "OEM"))
824 {
825 BMCWEB_LOG_ERROR << "Wrong parameter values passed";
826 messages::invalidObject(asyncResp->res,
827 "System Dump creation parameters");
828 return;
829 }
830 }
831 else if (dumpType == "BMC")
832 {
833 if (!diagnosticDataType)
834 {
835 BMCWEB_LOG_ERROR << "CreateDump action parameter "
836 "'DiagnosticDataType' not found!";
837 messages::actionParameterMissing(
838 asyncResp->res, "CollectDiagnosticData", "DiagnosticDataType");
839 return;
840 }
841 else if (*diagnosticDataType != "Manager")
842 {
843 BMCWEB_LOG_ERROR
844 << "Wrong parameter value passed for 'DiagnosticDataType'";
845 messages::invalidObject(asyncResp->res,
846 "BMC Dump creation parameters");
847 return;
848 }
849 }
850
851 crow::connections::systemBus->async_method_call(
852 [asyncResp, req, dumpPath, dumpType](const boost::system::error_code ec,
853 const uint32_t& dumpId) {
854 if (ec)
855 {
856 BMCWEB_LOG_ERROR << "CreateDump resp_handler got error " << ec;
857 messages::internalError(asyncResp->res);
858 return;
859 }
860 BMCWEB_LOG_DEBUG << "Dump Created. Id: " << dumpId;
861
862 createDumpTaskCallback(req, asyncResp, dumpId, dumpPath, dumpType);
863 },
864 "xyz.openbmc_project.Dump.Manager", "/xyz/openbmc_project/dump",
865 "xyz.openbmc_project.Dump.Create", "CreateDump");
866}
867
Asmitha Karunanithi80319af2020-05-07 05:30:21 -0500868inline void clearDump(crow::Response& res, const std::string& dumpInterface)
869{
870 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
871 crow::connections::systemBus->async_method_call(
872 [asyncResp](const boost::system::error_code ec,
873 const std::vector<std::string>& subTreePaths) {
874 if (ec)
875 {
876 BMCWEB_LOG_ERROR << "resp_handler got error " << ec;
877 messages::internalError(asyncResp->res);
878 return;
879 }
880
881 for (const std::string& path : subTreePaths)
882 {
883 std::size_t pos = path.rfind("/");
884 if (pos != std::string::npos)
885 {
886 std::string logID = path.substr(pos + 1);
887 deleteDumpEntry(asyncResp->res, logID);
888 }
889 }
890 },
891 "xyz.openbmc_project.ObjectMapper",
892 "/xyz/openbmc_project/object_mapper",
893 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
894 "/xyz/openbmc_project/dump", 0,
895 std::array<std::string, 1>{dumpInterface});
896}
897
Johnathan Mantey043a0532020-03-10 17:15:28 -0700898static void ParseCrashdumpParameters(
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500899 const std::vector<std::pair<std::string, VariantType>>& params,
900 std::string& filename, std::string& timestamp, std::string& logfile)
Johnathan Mantey043a0532020-03-10 17:15:28 -0700901{
902 for (auto property : params)
903 {
904 if (property.first == "Timestamp")
905 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500906 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500907 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700908 if (value != nullptr)
909 {
910 timestamp = *value;
911 }
912 }
913 else if (property.first == "Filename")
914 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500915 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500916 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700917 if (value != nullptr)
918 {
919 filename = *value;
920 }
921 }
922 else if (property.first == "Log")
923 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500924 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500925 std::get_if<std::string>(&property.second);
Johnathan Mantey043a0532020-03-10 17:15:28 -0700926 if (value != nullptr)
927 {
928 logfile = *value;
929 }
930 }
931 }
932}
933
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500934constexpr char const* postCodeIface = "xyz.openbmc_project.State.Boot.PostCode";
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800935class SystemLogServiceCollection : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -0700936{
937 public:
Ed Tanous52cc1122020-07-18 13:51:21 -0700938 SystemLogServiceCollection(App& app) :
Ed Tanous029573d2019-02-01 10:57:49 -0800939 Node(app, "/redfish/v1/Systems/system/LogServices/")
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800940 {
941 entityPrivileges = {
942 {boost::beast::http::verb::get, {{"Login"}}},
943 {boost::beast::http::verb::head, {{"Login"}}},
944 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
945 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
946 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
947 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
948 }
949
950 private:
951 /**
952 * Functions triggers appropriate requests on DBus
953 */
Ed Tanouscb13a392020-07-25 19:02:03 +0000954 void doGet(crow::Response& res, const crow::Request&,
955 const std::vector<std::string>&) override
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800956 {
957 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800958 // Collections don't include the static data added by SubRoute because
959 // it has a duplicate entry for members
960 asyncResp->res.jsonValue["@odata.type"] =
961 "#LogServiceCollection.LogServiceCollection";
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800962 asyncResp->res.jsonValue["@odata.id"] =
Ed Tanous029573d2019-02-01 10:57:49 -0800963 "/redfish/v1/Systems/system/LogServices";
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800964 asyncResp->res.jsonValue["Name"] = "System Log Services Collection";
965 asyncResp->res.jsonValue["Description"] =
966 "Collection of LogServices for this Computer System";
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500967 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800968 logServiceArray = nlohmann::json::array();
Ed Tanous029573d2019-02-01 10:57:49 -0800969 logServiceArray.push_back(
970 {{"@odata.id", "/redfish/v1/Systems/system/LogServices/EventLog"}});
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500971#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
raviteja-bc9bb6862020-02-03 11:53:32 -0600972 logServiceArray.push_back(
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -0500973 {{"@odata.id", "/redfish/v1/Systems/system/LogServices/Dump"}});
raviteja-bc9bb6862020-02-03 11:53:32 -0600974#endif
975
Jason M. Billsd53dd412019-02-12 17:16:22 -0800976#ifdef BMCWEB_ENABLE_REDFISH_CPU_LOG
977 logServiceArray.push_back(
Anthony Wilson08a4e4b2019-04-12 08:23:05 -0500978 {{"@odata.id",
979 "/redfish/v1/Systems/system/LogServices/Crashdump"}});
Jason M. Billsd53dd412019-02-12 17:16:22 -0800980#endif
Jason M. Billsc4bf6372018-11-05 13:48:27 -0800981 asyncResp->res.jsonValue["Members@odata.count"] =
982 logServiceArray.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -0800983
984 crow::connections::systemBus->async_method_call(
985 [asyncResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500986 const std::vector<std::string>& subtreePath) {
ZhikuiRena3316fc2020-01-29 14:58:08 -0800987 if (ec)
988 {
989 BMCWEB_LOG_ERROR << ec;
990 return;
991 }
992
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500993 for (auto& pathStr : subtreePath)
ZhikuiRena3316fc2020-01-29 14:58:08 -0800994 {
995 if (pathStr.find("PostCode") != std::string::npos)
996 {
Ed Tanous23a21a12020-07-25 04:45:05 +0000997 nlohmann::json& logServiceArrayLocal =
ZhikuiRena3316fc2020-01-29 14:58:08 -0800998 asyncResp->res.jsonValue["Members"];
Ed Tanous23a21a12020-07-25 04:45:05 +0000999 logServiceArrayLocal.push_back(
ZhikuiRena3316fc2020-01-29 14:58:08 -08001000 {{"@odata.id", "/redfish/v1/Systems/system/"
1001 "LogServices/PostCodes"}});
1002 asyncResp->res.jsonValue["Members@odata.count"] =
Ed Tanous23a21a12020-07-25 04:45:05 +00001003 logServiceArrayLocal.size();
ZhikuiRena3316fc2020-01-29 14:58:08 -08001004 return;
1005 }
1006 }
1007 },
1008 "xyz.openbmc_project.ObjectMapper",
1009 "/xyz/openbmc_project/object_mapper",
1010 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/", 0,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001011 std::array<const char*, 1>{postCodeIface});
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001012 }
1013};
1014
1015class EventLogService : public Node
1016{
1017 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001018 EventLogService(App& app) :
Ed Tanous029573d2019-02-01 10:57:49 -08001019 Node(app, "/redfish/v1/Systems/system/LogServices/EventLog/")
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001020 {
1021 entityPrivileges = {
1022 {boost::beast::http::verb::get, {{"Login"}}},
1023 {boost::beast::http::verb::head, {{"Login"}}},
1024 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1025 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1026 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1027 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1028 }
1029
1030 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001031 void doGet(crow::Response& res, const crow::Request&,
1032 const std::vector<std::string>&) override
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001033 {
1034 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1035
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001036 asyncResp->res.jsonValue["@odata.id"] =
Ed Tanous029573d2019-02-01 10:57:49 -08001037 "/redfish/v1/Systems/system/LogServices/EventLog";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001038 asyncResp->res.jsonValue["@odata.type"] =
1039 "#LogService.v1_1_0.LogService";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001040 asyncResp->res.jsonValue["Name"] = "Event Log Service";
1041 asyncResp->res.jsonValue["Description"] = "System Event Log Service";
Gunnar Mills73ec8302020-04-14 16:02:42 -05001042 asyncResp->res.jsonValue["Id"] = "EventLog";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001043 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
1044 asyncResp->res.jsonValue["Entries"] = {
1045 {"@odata.id",
Ed Tanous029573d2019-02-01 10:57:49 -08001046 "/redfish/v1/Systems/system/LogServices/EventLog/Entries"}};
Gunnar Millse7d6c8b2019-07-03 11:30:01 -05001047 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
1048
1049 {"target", "/redfish/v1/Systems/system/LogServices/EventLog/"
1050 "Actions/LogService.ClearLog"}};
Jason M. Bills489640c2019-05-17 09:56:36 -07001051 }
1052};
1053
Tim Lee1f56a3a2019-10-09 10:17:57 +08001054class JournalEventLogClear : public Node
Jason M. Bills489640c2019-05-17 09:56:36 -07001055{
1056 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001057 JournalEventLogClear(App& app) :
Jason M. Bills489640c2019-05-17 09:56:36 -07001058 Node(app, "/redfish/v1/Systems/system/LogServices/EventLog/Actions/"
1059 "LogService.ClearLog/")
1060 {
1061 entityPrivileges = {
1062 {boost::beast::http::verb::get, {{"Login"}}},
1063 {boost::beast::http::verb::head, {{"Login"}}},
1064 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1065 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1066 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1067 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
1068 }
1069
1070 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001071 void doPost(crow::Response& res, const crow::Request&,
1072 const std::vector<std::string>&) override
Jason M. Bills489640c2019-05-17 09:56:36 -07001073 {
1074 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1075
1076 // Clear the EventLog by deleting the log files
1077 std::vector<std::filesystem::path> redfishLogFiles;
1078 if (getRedfishLogFiles(redfishLogFiles))
1079 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001080 for (const std::filesystem::path& file : redfishLogFiles)
Jason M. Bills489640c2019-05-17 09:56:36 -07001081 {
1082 std::error_code ec;
1083 std::filesystem::remove(file, ec);
1084 }
1085 }
1086
1087 // Reload rsyslog so it knows to start new log files
1088 crow::connections::systemBus->async_method_call(
1089 [asyncResp](const boost::system::error_code ec) {
1090 if (ec)
1091 {
1092 BMCWEB_LOG_ERROR << "Failed to reload rsyslog: " << ec;
1093 messages::internalError(asyncResp->res);
1094 return;
1095 }
1096
1097 messages::success(asyncResp->res);
1098 },
1099 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
1100 "org.freedesktop.systemd1.Manager", "ReloadUnit", "rsyslog.service",
1101 "replace");
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001102 }
1103};
1104
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001105static int fillEventLogEntryJson(const std::string& logEntryID,
Jason M. Bills95820182019-04-22 16:25:34 -07001106 const std::string logEntry,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001107 nlohmann::json& logEntryJson)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001108{
Jason M. Bills95820182019-04-22 16:25:34 -07001109 // The redfish log format is "<Timestamp> <MessageId>,<MessageArgs>"
Jason M. Billscd225da2019-05-08 15:31:57 -07001110 // First get the Timestamp
1111 size_t space = logEntry.find_first_of(" ");
1112 if (space == std::string::npos)
Jason M. Bills95820182019-04-22 16:25:34 -07001113 {
1114 return 1;
1115 }
Jason M. Billscd225da2019-05-08 15:31:57 -07001116 std::string timestamp = logEntry.substr(0, space);
1117 // Then get the log contents
1118 size_t entryStart = logEntry.find_first_not_of(" ", space);
1119 if (entryStart == std::string::npos)
1120 {
1121 return 1;
1122 }
1123 std::string_view entry(logEntry);
1124 entry.remove_prefix(entryStart);
1125 // Use split to separate the entry into its fields
1126 std::vector<std::string> logEntryFields;
1127 boost::split(logEntryFields, entry, boost::is_any_of(","),
1128 boost::token_compress_on);
1129 // We need at least a MessageId to be valid
1130 if (logEntryFields.size() < 1)
1131 {
1132 return 1;
1133 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001134 std::string& messageID = logEntryFields[0];
Jason M. Bills95820182019-04-22 16:25:34 -07001135
Jason M. Bills4851d452019-03-28 11:27:48 -07001136 // Get the Message from the MessageRegistry
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001137 const message_registries::Message* message =
Jason M. Bills4851d452019-03-28 11:27:48 -07001138 message_registries::getMessage(messageID);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001139
Jason M. Bills4851d452019-03-28 11:27:48 -07001140 std::string msg;
1141 std::string severity;
1142 if (message != nullptr)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001143 {
Jason M. Bills4851d452019-03-28 11:27:48 -07001144 msg = message->message;
1145 severity = message->severity;
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001146 }
1147
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001148 // Get the MessageArgs from the log if there are any
1149 boost::beast::span<std::string> messageArgs;
1150 if (logEntryFields.size() > 1)
Jason M. Bills4851d452019-03-28 11:27:48 -07001151 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001152 std::string& messageArgsStart = logEntryFields[1];
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001153 // If the first string is empty, assume there are no MessageArgs
1154 std::size_t messageArgsSize = 0;
1155 if (!messageArgsStart.empty())
Jason M. Bills4851d452019-03-28 11:27:48 -07001156 {
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001157 messageArgsSize = logEntryFields.size() - 1;
1158 }
1159
Ed Tanous23a21a12020-07-25 04:45:05 +00001160 messageArgs = {&messageArgsStart, messageArgsSize};
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001161
1162 // Fill the MessageArgs into the Message
1163 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001164 for (const std::string& messageArg : messageArgs)
Jason M. Bills15a86ff2019-06-18 13:49:54 -07001165 {
1166 std::string argStr = "%" + std::to_string(++i);
1167 size_t argPos = msg.find(argStr);
1168 if (argPos != std::string::npos)
1169 {
1170 msg.replace(argPos, argStr.length(), messageArg);
1171 }
Jason M. Bills4851d452019-03-28 11:27:48 -07001172 }
1173 }
1174
Jason M. Bills95820182019-04-22 16:25:34 -07001175 // Get the Created time from the timestamp. The log timestamp is in RFC3339
1176 // format which matches the Redfish format except for the fractional seconds
1177 // between the '.' and the '+', so just remove them.
1178 std::size_t dot = timestamp.find_first_of(".");
1179 std::size_t plus = timestamp.find_first_of("+");
1180 if (dot != std::string::npos && plus != std::string::npos)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001181 {
Jason M. Bills95820182019-04-22 16:25:34 -07001182 timestamp.erase(dot, plus - dot);
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001183 }
1184
1185 // Fill in the log entry with the gathered data
Jason M. Bills95820182019-04-22 16:25:34 -07001186 logEntryJson = {
Andrew Geisslercb92c032018-08-17 07:56:14 -07001187 {"@odata.type", "#LogEntry.v1_4_0.LogEntry"},
Ed Tanous029573d2019-02-01 10:57:49 -08001188 {"@odata.id",
Jason M. Bills897967d2019-07-29 17:05:30 -07001189 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/" +
Jason M. Bills95820182019-04-22 16:25:34 -07001190 logEntryID},
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001191 {"Name", "System Event Log Entry"},
Jason M. Bills95820182019-04-22 16:25:34 -07001192 {"Id", logEntryID},
1193 {"Message", std::move(msg)},
1194 {"MessageId", std::move(messageID)},
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001195 {"MessageArgs", std::move(messageArgs)},
1196 {"EntryType", "Event"},
Jason M. Bills95820182019-04-22 16:25:34 -07001197 {"Severity", std::move(severity)},
1198 {"Created", std::move(timestamp)}};
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001199 return 0;
1200}
1201
Anthony Wilson27062602019-04-22 02:10:09 -05001202class JournalEventLogEntryCollection : public Node
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001203{
1204 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001205 JournalEventLogEntryCollection(App& app) :
Ed Tanous029573d2019-02-01 10:57:49 -08001206 Node(app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001207 {
1208 entityPrivileges = {
1209 {boost::beast::http::verb::get, {{"Login"}}},
1210 {boost::beast::http::verb::head, {{"Login"}}},
1211 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1212 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1213 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1214 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1215 }
1216
1217 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001218 void doGet(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00001219 const std::vector<std::string>&) override
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001220 {
1221 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous271584a2019-07-09 16:24:22 -07001222 uint64_t skip = 0;
1223 uint64_t top = maxEntriesPerPage; // Show max entries by default
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001224 if (!getSkipParam(asyncResp->res, req, skip))
1225 {
1226 return;
1227 }
1228 if (!getTopParam(asyncResp->res, req, top))
1229 {
1230 return;
1231 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001232 // Collections don't include the static data added by SubRoute because
1233 // it has a duplicate entry for members
1234 asyncResp->res.jsonValue["@odata.type"] =
1235 "#LogEntryCollection.LogEntryCollection";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001236 asyncResp->res.jsonValue["@odata.id"] =
Ed Tanous029573d2019-02-01 10:57:49 -08001237 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001238 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1239 asyncResp->res.jsonValue["Description"] =
1240 "Collection of System Event Log Entries";
Andrew Geisslercb92c032018-08-17 07:56:14 -07001241
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001242 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001243 logEntryArray = nlohmann::json::array();
Jason M. Bills95820182019-04-22 16:25:34 -07001244 // Go through the log files and create a unique ID for each entry
1245 std::vector<std::filesystem::path> redfishLogFiles;
1246 getRedfishLogFiles(redfishLogFiles);
Ed Tanousb01bf292019-03-25 19:25:26 +00001247 uint64_t entryCount = 0;
Jason M. Billscd225da2019-05-08 15:31:57 -07001248 std::string logEntry;
Jason M. Bills95820182019-04-22 16:25:34 -07001249
1250 // Oldest logs are in the last file, so start there and loop backwards
Jason M. Billscd225da2019-05-08 15:31:57 -07001251 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1252 it++)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001253 {
Jason M. Billscd225da2019-05-08 15:31:57 -07001254 std::ifstream logStream(*it);
Jason M. Bills95820182019-04-22 16:25:34 -07001255 if (!logStream.is_open())
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001256 {
1257 continue;
1258 }
1259
Jason M. Billse85d6b12019-07-29 17:01:15 -07001260 // Reset the unique ID on the first entry
1261 bool firstEntry = true;
Jason M. Bills95820182019-04-22 16:25:34 -07001262 while (std::getline(logStream, logEntry))
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001263 {
Jason M. Bills95820182019-04-22 16:25:34 -07001264 entryCount++;
1265 // Handle paging using skip (number of entries to skip from the
1266 // start) and top (number of entries to display)
1267 if (entryCount <= skip || entryCount > skip + top)
1268 {
1269 continue;
1270 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001271
Jason M. Bills95820182019-04-22 16:25:34 -07001272 std::string idStr;
Jason M. Billse85d6b12019-07-29 17:01:15 -07001273 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
Jason M. Bills95820182019-04-22 16:25:34 -07001274 {
1275 continue;
1276 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001277
Jason M. Billse85d6b12019-07-29 17:01:15 -07001278 if (firstEntry)
1279 {
1280 firstEntry = false;
1281 }
1282
Jason M. Bills95820182019-04-22 16:25:34 -07001283 logEntryArray.push_back({});
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001284 nlohmann::json& bmcLogEntry = logEntryArray.back();
Jason M. Bills95820182019-04-22 16:25:34 -07001285 if (fillEventLogEntryJson(idStr, logEntry, bmcLogEntry) != 0)
1286 {
1287 messages::internalError(asyncResp->res);
1288 return;
1289 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001290 }
1291 }
1292 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
1293 if (skip + top < entryCount)
1294 {
1295 asyncResp->res.jsonValue["Members@odata.nextLink"] =
Jason M. Bills95820182019-04-22 16:25:34 -07001296 "/redfish/v1/Systems/system/LogServices/EventLog/"
1297 "Entries?$skip=" +
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001298 std::to_string(skip + top);
1299 }
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001300 }
1301};
1302
Jason M. Bills897967d2019-07-29 17:05:30 -07001303class JournalEventLogEntry : public Node
1304{
1305 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001306 JournalEventLogEntry(App& app) :
Jason M. Bills897967d2019-07-29 17:05:30 -07001307 Node(app,
1308 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/",
1309 std::string())
1310 {
1311 entityPrivileges = {
1312 {boost::beast::http::verb::get, {{"Login"}}},
1313 {boost::beast::http::verb::head, {{"Login"}}},
1314 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1315 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1316 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1317 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1318 }
1319
1320 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001321 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001322 const std::vector<std::string>& params) override
Jason M. Bills897967d2019-07-29 17:05:30 -07001323 {
1324 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1325 if (params.size() != 1)
1326 {
1327 messages::internalError(asyncResp->res);
1328 return;
1329 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001330 const std::string& targetID = params[0];
Jason M. Bills897967d2019-07-29 17:05:30 -07001331
1332 // Go through the log files and check the unique ID for each entry to
1333 // find the target entry
1334 std::vector<std::filesystem::path> redfishLogFiles;
1335 getRedfishLogFiles(redfishLogFiles);
1336 std::string logEntry;
1337
1338 // Oldest logs are in the last file, so start there and loop backwards
1339 for (auto it = redfishLogFiles.rbegin(); it < redfishLogFiles.rend();
1340 it++)
1341 {
1342 std::ifstream logStream(*it);
1343 if (!logStream.is_open())
1344 {
1345 continue;
1346 }
1347
1348 // Reset the unique ID on the first entry
1349 bool firstEntry = true;
1350 while (std::getline(logStream, logEntry))
1351 {
1352 std::string idStr;
1353 if (!getUniqueEntryID(logEntry, idStr, firstEntry))
1354 {
1355 continue;
1356 }
1357
1358 if (firstEntry)
1359 {
1360 firstEntry = false;
1361 }
1362
1363 if (idStr == targetID)
1364 {
1365 if (fillEventLogEntryJson(idStr, logEntry,
1366 asyncResp->res.jsonValue) != 0)
1367 {
1368 messages::internalError(asyncResp->res);
1369 return;
1370 }
1371 return;
1372 }
1373 }
1374 }
1375 // Requested ID was not found
1376 messages::resourceMissingAtURI(asyncResp->res, targetID);
1377 }
1378};
1379
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001380class DBusEventLogEntryCollection : public Node
1381{
1382 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001383 DBusEventLogEntryCollection(App& app) :
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001384 Node(app, "/redfish/v1/Systems/system/LogServices/EventLog/Entries/")
1385 {
1386 entityPrivileges = {
1387 {boost::beast::http::verb::get, {{"Login"}}},
1388 {boost::beast::http::verb::head, {{"Login"}}},
1389 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1390 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1391 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1392 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1393 }
1394
1395 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001396 void doGet(crow::Response& res, const crow::Request&,
1397 const std::vector<std::string>&) override
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001398 {
1399 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1400
1401 // Collections don't include the static data added by SubRoute because
1402 // it has a duplicate entry for members
1403 asyncResp->res.jsonValue["@odata.type"] =
1404 "#LogEntryCollection.LogEntryCollection";
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001405 asyncResp->res.jsonValue["@odata.id"] =
1406 "/redfish/v1/Systems/system/LogServices/EventLog/Entries";
1407 asyncResp->res.jsonValue["Name"] = "System Event Log Entries";
1408 asyncResp->res.jsonValue["Description"] =
1409 "Collection of System Event Log Entries";
1410
Andrew Geisslercb92c032018-08-17 07:56:14 -07001411 // DBus implementation of EventLog/Entries
1412 // Make call to Logging Service to find all log entry objects
1413 crow::connections::systemBus->async_method_call(
1414 [asyncResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001415 GetManagedObjectsType& resp) {
Andrew Geisslercb92c032018-08-17 07:56:14 -07001416 if (ec)
1417 {
1418 // TODO Handle for specific error code
1419 BMCWEB_LOG_ERROR
1420 << "getLogEntriesIfaceData resp_handler got error "
1421 << ec;
1422 messages::internalError(asyncResp->res);
1423 return;
1424 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001425 nlohmann::json& entriesArray =
Andrew Geisslercb92c032018-08-17 07:56:14 -07001426 asyncResp->res.jsonValue["Members"];
1427 entriesArray = nlohmann::json::array();
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001428 for (auto& objectPath : resp)
Andrew Geisslercb92c032018-08-17 07:56:14 -07001429 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001430 for (auto& interfaceMap : objectPath.second)
Andrew Geisslercb92c032018-08-17 07:56:14 -07001431 {
1432 if (interfaceMap.first !=
1433 "xyz.openbmc_project.Logging.Entry")
1434 {
1435 BMCWEB_LOG_DEBUG << "Bailing early on "
1436 << interfaceMap.first;
1437 continue;
1438 }
1439 entriesArray.push_back({});
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001440 nlohmann::json& thisEntry = entriesArray.back();
1441 uint32_t* id = nullptr;
Ed Tanous66664f22019-10-11 13:05:49 -07001442 std::time_t timestamp{};
George Liud139c232020-08-18 18:48:57 +08001443 std::time_t updateTimestamp{};
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001444 std::string* severity = nullptr;
1445 std::string* message = nullptr;
George Liud139c232020-08-18 18:48:57 +08001446
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001447 for (auto& propertyMap : interfaceMap.second)
Andrew Geisslercb92c032018-08-17 07:56:14 -07001448 {
1449 if (propertyMap.first == "Id")
1450 {
Patrick Williams8d78b7a2020-05-13 11:24:20 -05001451 id = std::get_if<uint32_t>(&propertyMap.second);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001452 if (id == nullptr)
1453 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001454 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001455 }
1456 }
1457 else if (propertyMap.first == "Timestamp")
1458 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001459 const uint64_t* millisTimeStamp =
Andrew Geisslercb92c032018-08-17 07:56:14 -07001460 std::get_if<uint64_t>(&propertyMap.second);
1461 if (millisTimeStamp == nullptr)
1462 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001463 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001464 }
George Liud139c232020-08-18 18:48:57 +08001465 timestamp = crow::utility::getTimestamp(
Andrew Geisslercb92c032018-08-17 07:56:14 -07001466 *millisTimeStamp);
George Liud139c232020-08-18 18:48:57 +08001467 }
1468 else if (propertyMap.first == "UpdateTimestamp")
1469 {
1470 const uint64_t* millisTimeStamp =
1471 std::get_if<uint64_t>(&propertyMap.second);
1472 if (millisTimeStamp == nullptr)
1473 {
1474 messages::internalError(asyncResp->res);
1475 }
1476 updateTimestamp = crow::utility::getTimestamp(
1477 *millisTimeStamp);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001478 }
1479 else if (propertyMap.first == "Severity")
1480 {
1481 severity = std::get_if<std::string>(
1482 &propertyMap.second);
1483 if (severity == nullptr)
1484 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001485 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001486 }
1487 }
1488 else if (propertyMap.first == "Message")
1489 {
1490 message = std::get_if<std::string>(
1491 &propertyMap.second);
1492 if (message == nullptr)
1493 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001494 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001495 }
1496 }
1497 }
1498 thisEntry = {
George Liud139c232020-08-18 18:48:57 +08001499 {"@odata.type", "#LogEntry.v1_6_0.LogEntry"},
Andrew Geisslercb92c032018-08-17 07:56:14 -07001500 {"@odata.id",
1501 "/redfish/v1/Systems/system/LogServices/EventLog/"
1502 "Entries/" +
1503 std::to_string(*id)},
Anthony Wilson27062602019-04-22 02:10:09 -05001504 {"Name", "System Event Log Entry"},
Andrew Geisslercb92c032018-08-17 07:56:14 -07001505 {"Id", std::to_string(*id)},
1506 {"Message", *message},
1507 {"EntryType", "Event"},
1508 {"Severity",
1509 translateSeverityDbusToRedfish(*severity)},
George Liud139c232020-08-18 18:48:57 +08001510 {"Created", crow::utility::getDateTime(timestamp)},
1511 {"Modified",
1512 crow::utility::getDateTime(updateTimestamp)}};
Andrew Geisslercb92c032018-08-17 07:56:14 -07001513 }
1514 }
1515 std::sort(entriesArray.begin(), entriesArray.end(),
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001516 [](const nlohmann::json& left,
1517 const nlohmann::json& right) {
Andrew Geisslercb92c032018-08-17 07:56:14 -07001518 return (left["Id"] <= right["Id"]);
1519 });
1520 asyncResp->res.jsonValue["Members@odata.count"] =
1521 entriesArray.size();
1522 },
1523 "xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
1524 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001525 }
1526};
1527
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001528class DBusEventLogEntry : public Node
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001529{
1530 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001531 DBusEventLogEntry(App& app) :
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001532 Node(app,
Ed Tanous029573d2019-02-01 10:57:49 -08001533 "/redfish/v1/Systems/system/LogServices/EventLog/Entries/<str>/",
1534 std::string())
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001535 {
1536 entityPrivileges = {
1537 {boost::beast::http::verb::get, {{"Login"}}},
1538 {boost::beast::http::verb::head, {{"Login"}}},
1539 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1540 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1541 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1542 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1543 }
1544
1545 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001546 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001547 const std::vector<std::string>& params) override
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001548 {
1549 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous029573d2019-02-01 10:57:49 -08001550 if (params.size() != 1)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001551 {
1552 messages::internalError(asyncResp->res);
1553 return;
1554 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001555 const std::string& entryID = params[0];
Andrew Geisslercb92c032018-08-17 07:56:14 -07001556
Andrew Geisslercb92c032018-08-17 07:56:14 -07001557 // DBus implementation of EventLog/Entries
1558 // Make call to Logging Service to find all log entry objects
1559 crow::connections::systemBus->async_method_call(
1560 [asyncResp, entryID](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001561 GetManagedPropertyType& resp) {
Andrew Geisslercb92c032018-08-17 07:56:14 -07001562 if (ec)
1563 {
1564 BMCWEB_LOG_ERROR
1565 << "EventLogEntry (DBus) resp_handler got error " << ec;
1566 messages::internalError(asyncResp->res);
1567 return;
1568 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001569 uint32_t* id = nullptr;
Ed Tanous66664f22019-10-11 13:05:49 -07001570 std::time_t timestamp{};
George Liud139c232020-08-18 18:48:57 +08001571 std::time_t updateTimestamp{};
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001572 std::string* severity = nullptr;
1573 std::string* message = nullptr;
George Liud139c232020-08-18 18:48:57 +08001574
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001575 for (auto& propertyMap : resp)
Andrew Geisslercb92c032018-08-17 07:56:14 -07001576 {
1577 if (propertyMap.first == "Id")
1578 {
1579 id = std::get_if<uint32_t>(&propertyMap.second);
1580 if (id == nullptr)
1581 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001582 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001583 }
1584 }
1585 else if (propertyMap.first == "Timestamp")
1586 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001587 const uint64_t* millisTimeStamp =
Andrew Geisslercb92c032018-08-17 07:56:14 -07001588 std::get_if<uint64_t>(&propertyMap.second);
1589 if (millisTimeStamp == nullptr)
1590 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001591 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001592 }
Andrew Geisslercb92c032018-08-17 07:56:14 -07001593 timestamp =
George Liud139c232020-08-18 18:48:57 +08001594 crow::utility::getTimestamp(*millisTimeStamp);
1595 }
1596 else if (propertyMap.first == "UpdateTimestamp")
1597 {
1598 const uint64_t* millisTimeStamp =
1599 std::get_if<uint64_t>(&propertyMap.second);
1600 if (millisTimeStamp == nullptr)
1601 {
1602 messages::internalError(asyncResp->res);
1603 }
1604 updateTimestamp =
1605 crow::utility::getTimestamp(*millisTimeStamp);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001606 }
1607 else if (propertyMap.first == "Severity")
1608 {
1609 severity =
1610 std::get_if<std::string>(&propertyMap.second);
1611 if (severity == nullptr)
1612 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001613 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001614 }
1615 }
1616 else if (propertyMap.first == "Message")
1617 {
1618 message = std::get_if<std::string>(&propertyMap.second);
1619 if (message == nullptr)
1620 {
Asmitha Karunanithi0f1d8ed2020-08-02 11:11:47 -05001621 messages::internalError(asyncResp->res);
Andrew Geisslercb92c032018-08-17 07:56:14 -07001622 }
1623 }
1624 }
Ed Tanous271584a2019-07-09 16:24:22 -07001625 if (id == nullptr || message == nullptr || severity == nullptr)
1626 {
1627 return;
1628 }
Andrew Geisslercb92c032018-08-17 07:56:14 -07001629 asyncResp->res.jsonValue = {
George Liud139c232020-08-18 18:48:57 +08001630 {"@odata.type", "#LogEntry.v1_6_0.LogEntry"},
Andrew Geisslercb92c032018-08-17 07:56:14 -07001631 {"@odata.id",
1632 "/redfish/v1/Systems/system/LogServices/EventLog/"
1633 "Entries/" +
1634 std::to_string(*id)},
Anthony Wilson27062602019-04-22 02:10:09 -05001635 {"Name", "System Event Log Entry"},
Andrew Geisslercb92c032018-08-17 07:56:14 -07001636 {"Id", std::to_string(*id)},
1637 {"Message", *message},
1638 {"EntryType", "Event"},
1639 {"Severity", translateSeverityDbusToRedfish(*severity)},
George Liud139c232020-08-18 18:48:57 +08001640 {"Created", crow::utility::getDateTime(timestamp)},
1641 {"Modified", crow::utility::getDateTime(updateTimestamp)}};
Andrew Geisslercb92c032018-08-17 07:56:14 -07001642 },
1643 "xyz.openbmc_project.Logging",
1644 "/xyz/openbmc_project/logging/entry/" + entryID,
1645 "org.freedesktop.DBus.Properties", "GetAll",
1646 "xyz.openbmc_project.Logging.Entry");
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001647 }
Chicago Duan336e96c2019-07-15 14:22:08 +08001648
Ed Tanouscb13a392020-07-25 19:02:03 +00001649 void doDelete(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001650 const std::vector<std::string>& params) override
Chicago Duan336e96c2019-07-15 14:22:08 +08001651 {
1652
1653 BMCWEB_LOG_DEBUG << "Do delete single event entries.";
1654
1655 auto asyncResp = std::make_shared<AsyncResp>(res);
1656
1657 if (params.size() != 1)
1658 {
1659 messages::internalError(asyncResp->res);
1660 return;
1661 }
1662 std::string entryID = params[0];
1663
1664 dbus::utility::escapePathForDbus(entryID);
1665
1666 // Process response from Logging service.
1667 auto respHandler = [asyncResp](const boost::system::error_code ec) {
1668 BMCWEB_LOG_DEBUG << "EventLogEntry (DBus) doDelete callback: Done";
1669 if (ec)
1670 {
1671 // TODO Handle for specific error code
1672 BMCWEB_LOG_ERROR
1673 << "EventLogEntry (DBus) doDelete respHandler got error "
1674 << ec;
1675 asyncResp->res.result(
1676 boost::beast::http::status::internal_server_error);
1677 return;
1678 }
1679
1680 asyncResp->res.result(boost::beast::http::status::ok);
1681 };
1682
1683 // Make call to Logging service to request Delete Log
1684 crow::connections::systemBus->async_method_call(
1685 respHandler, "xyz.openbmc_project.Logging",
1686 "/xyz/openbmc_project/logging/entry/" + entryID,
1687 "xyz.openbmc_project.Object.Delete", "Delete");
1688 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001689};
1690
1691class BMCLogServiceCollection : public Node
1692{
1693 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001694 BMCLogServiceCollection(App& app) :
Ed Tanous4ed77cd2018-10-15 08:08:07 -07001695 Node(app, "/redfish/v1/Managers/bmc/LogServices/")
Ed Tanous1da66f72018-07-27 16:13:37 -07001696 {
Ed Tanous1da66f72018-07-27 16:13:37 -07001697 entityPrivileges = {
Jason M. Billse1f26342018-07-18 12:12:00 -07001698 {boost::beast::http::verb::get, {{"Login"}}},
1699 {boost::beast::http::verb::head, {{"Login"}}},
1700 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1701 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1702 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1703 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07001704 }
1705
1706 private:
1707 /**
1708 * Functions triggers appropriate requests on DBus
1709 */
Ed Tanouscb13a392020-07-25 19:02:03 +00001710 void doGet(crow::Response& res, const crow::Request&,
1711 const std::vector<std::string>&) override
Ed Tanous1da66f72018-07-27 16:13:37 -07001712 {
Jason M. Billse1f26342018-07-18 12:12:00 -07001713 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1da66f72018-07-27 16:13:37 -07001714 // Collections don't include the static data added by SubRoute because
1715 // it has a duplicate entry for members
Jason M. Billse1f26342018-07-18 12:12:00 -07001716 asyncResp->res.jsonValue["@odata.type"] =
Ed Tanous1da66f72018-07-27 16:13:37 -07001717 "#LogServiceCollection.LogServiceCollection";
Jason M. Billse1f26342018-07-18 12:12:00 -07001718 asyncResp->res.jsonValue["@odata.id"] =
1719 "/redfish/v1/Managers/bmc/LogServices";
1720 asyncResp->res.jsonValue["Name"] = "Open BMC Log Services Collection";
1721 asyncResp->res.jsonValue["Description"] =
Ed Tanous1da66f72018-07-27 16:13:37 -07001722 "Collection of LogServices for this Manager";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001723 nlohmann::json& logServiceArray = asyncResp->res.jsonValue["Members"];
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001724 logServiceArray = nlohmann::json::array();
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05001725#ifdef BMCWEB_ENABLE_REDFISH_DUMP_LOG
1726 logServiceArray.push_back(
1727 {{"@odata.id", "/redfish/v1/Managers/bmc/LogServices/Dump"}});
1728#endif
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001729#ifdef BMCWEB_ENABLE_REDFISH_BMC_JOURNAL
1730 logServiceArray.push_back(
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05001731 {{"@odata.id", "/redfish/v1/Managers/bmc/LogServices/Journal"}});
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001732#endif
Jason M. Billse1f26342018-07-18 12:12:00 -07001733 asyncResp->res.jsonValue["Members@odata.count"] =
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001734 logServiceArray.size();
Ed Tanous1da66f72018-07-27 16:13:37 -07001735 }
1736};
1737
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001738class BMCJournalLogService : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -07001739{
1740 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001741 BMCJournalLogService(App& app) :
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001742 Node(app, "/redfish/v1/Managers/bmc/LogServices/Journal/")
Jason M. Billse1f26342018-07-18 12:12:00 -07001743 {
Jason M. Billse1f26342018-07-18 12:12:00 -07001744 entityPrivileges = {
1745 {boost::beast::http::verb::get, {{"Login"}}},
1746 {boost::beast::http::verb::head, {{"Login"}}},
1747 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1748 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1749 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1750 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1751 }
1752
1753 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001754 void doGet(crow::Response& res, const crow::Request&,
1755 const std::vector<std::string>&) override
Jason M. Billse1f26342018-07-18 12:12:00 -07001756 {
1757 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Jason M. Billse1f26342018-07-18 12:12:00 -07001758 asyncResp->res.jsonValue["@odata.type"] =
1759 "#LogService.v1_1_0.LogService";
Ed Tanous0f74e642018-11-12 15:17:05 -08001760 asyncResp->res.jsonValue["@odata.id"] =
1761 "/redfish/v1/Managers/bmc/LogServices/Journal";
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001762 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Log Service";
1763 asyncResp->res.jsonValue["Description"] = "BMC Journal Log Service";
1764 asyncResp->res.jsonValue["Id"] = "BMC Journal";
Jason M. Billse1f26342018-07-18 12:12:00 -07001765 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
Jason M. Billscd50aa42019-02-12 17:09:02 -08001766 asyncResp->res.jsonValue["Entries"] = {
1767 {"@odata.id",
Ed Tanous086be232019-05-23 11:47:09 -07001768 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries"}};
Jason M. Billse1f26342018-07-18 12:12:00 -07001769 }
1770};
1771
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001772static int fillBMCJournalLogEntryJson(const std::string& bmcJournalLogEntryID,
1773 sd_journal* journal,
1774 nlohmann::json& bmcJournalLogEntryJson)
Jason M. Billse1f26342018-07-18 12:12:00 -07001775{
1776 // Get the Log Entry contents
1777 int ret = 0;
Jason M. Billse1f26342018-07-18 12:12:00 -07001778
Ed Tanous39e77502019-03-04 17:35:53 -08001779 std::string_view msg;
Jason M. Bills16428a12018-11-02 12:42:29 -07001780 ret = getJournalMetadata(journal, "MESSAGE", msg);
Jason M. Billse1f26342018-07-18 12:12:00 -07001781 if (ret < 0)
1782 {
1783 BMCWEB_LOG_ERROR << "Failed to read MESSAGE field: " << strerror(-ret);
1784 return 1;
1785 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001786
1787 // Get the severity from the PRIORITY field
Ed Tanous271584a2019-07-09 16:24:22 -07001788 long int severity = 8; // Default to an invalid priority
Jason M. Bills16428a12018-11-02 12:42:29 -07001789 ret = getJournalMetadata(journal, "PRIORITY", 10, severity);
Jason M. Billse1f26342018-07-18 12:12:00 -07001790 if (ret < 0)
1791 {
1792 BMCWEB_LOG_ERROR << "Failed to read PRIORITY field: " << strerror(-ret);
Jason M. Billse1f26342018-07-18 12:12:00 -07001793 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001794
1795 // Get the Created time from the timestamp
Jason M. Bills16428a12018-11-02 12:42:29 -07001796 std::string entryTimeStr;
1797 if (!getEntryTimestamp(journal, entryTimeStr))
Jason M. Billse1f26342018-07-18 12:12:00 -07001798 {
Jason M. Bills16428a12018-11-02 12:42:29 -07001799 return 1;
Jason M. Billse1f26342018-07-18 12:12:00 -07001800 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001801
1802 // Fill in the log entry with the gathered data
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001803 bmcJournalLogEntryJson = {
Andrew Geisslercb92c032018-08-17 07:56:14 -07001804 {"@odata.type", "#LogEntry.v1_4_0.LogEntry"},
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001805 {"@odata.id", "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/" +
1806 bmcJournalLogEntryID},
Jason M. Billse1f26342018-07-18 12:12:00 -07001807 {"Name", "BMC Journal Entry"},
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001808 {"Id", bmcJournalLogEntryID},
Jason M. Bills16428a12018-11-02 12:42:29 -07001809 {"Message", msg},
Jason M. Billse1f26342018-07-18 12:12:00 -07001810 {"EntryType", "Oem"},
1811 {"Severity",
Jason M. Billsb6a61a52019-08-01 14:26:15 -07001812 severity <= 2 ? "Critical" : severity <= 4 ? "Warning" : "OK"},
Ed Tanous086be232019-05-23 11:47:09 -07001813 {"OemRecordFormat", "BMC Journal Entry"},
Jason M. Billse1f26342018-07-18 12:12:00 -07001814 {"Created", std::move(entryTimeStr)}};
1815 return 0;
1816}
1817
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001818class BMCJournalLogEntryCollection : public Node
Jason M. Billse1f26342018-07-18 12:12:00 -07001819{
1820 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001821 BMCJournalLogEntryCollection(App& app) :
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001822 Node(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/")
Jason M. Billse1f26342018-07-18 12:12:00 -07001823 {
Jason M. Billse1f26342018-07-18 12:12:00 -07001824 entityPrivileges = {
1825 {boost::beast::http::verb::get, {{"Login"}}},
1826 {boost::beast::http::verb::head, {{"Login"}}},
1827 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1828 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1829 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1830 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1831 }
1832
1833 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001834 void doGet(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00001835 const std::vector<std::string>&) override
Jason M. Billse1f26342018-07-18 12:12:00 -07001836 {
1837 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001838 static constexpr const long maxEntriesPerPage = 1000;
Ed Tanous271584a2019-07-09 16:24:22 -07001839 uint64_t skip = 0;
1840 uint64_t top = maxEntriesPerPage; // Show max entries by default
Jason M. Bills16428a12018-11-02 12:42:29 -07001841 if (!getSkipParam(asyncResp->res, req, skip))
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001842 {
Jason M. Bills16428a12018-11-02 12:42:29 -07001843 return;
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001844 }
Jason M. Bills16428a12018-11-02 12:42:29 -07001845 if (!getTopParam(asyncResp->res, req, top))
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001846 {
Jason M. Bills16428a12018-11-02 12:42:29 -07001847 return;
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001848 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001849 // Collections don't include the static data added by SubRoute because
1850 // it has a duplicate entry for members
1851 asyncResp->res.jsonValue["@odata.type"] =
1852 "#LogEntryCollection.LogEntryCollection";
Ed Tanous0f74e642018-11-12 15:17:05 -08001853 asyncResp->res.jsonValue["@odata.id"] =
1854 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
Jason M. Billse1f26342018-07-18 12:12:00 -07001855 asyncResp->res.jsonValue["@odata.id"] =
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001856 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries";
Jason M. Billse1f26342018-07-18 12:12:00 -07001857 asyncResp->res.jsonValue["Name"] = "Open BMC Journal Entries";
1858 asyncResp->res.jsonValue["Description"] =
1859 "Collection of BMC Journal Entries";
Ed Tanous0f74e642018-11-12 15:17:05 -08001860 asyncResp->res.jsonValue["@odata.id"] =
1861 "/redfish/v1/Managers/bmc/LogServices/BmcLog/Entries";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001862 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
Jason M. Billse1f26342018-07-18 12:12:00 -07001863 logEntryArray = nlohmann::json::array();
1864
1865 // Go through the journal and use the timestamp to create a unique ID
1866 // for each entry
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001867 sd_journal* journalTmp = nullptr;
Jason M. Billse1f26342018-07-18 12:12:00 -07001868 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
1869 if (ret < 0)
1870 {
1871 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
Jason M. Billsf12894f2018-10-09 12:45:45 -07001872 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07001873 return;
1874 }
1875 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
1876 journalTmp, sd_journal_close);
1877 journalTmp = nullptr;
Ed Tanousb01bf292019-03-25 19:25:26 +00001878 uint64_t entryCount = 0;
Jason M. Billse85d6b12019-07-29 17:01:15 -07001879 // Reset the unique ID on the first entry
1880 bool firstEntry = true;
Jason M. Billse1f26342018-07-18 12:12:00 -07001881 SD_JOURNAL_FOREACH(journal.get())
1882 {
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001883 entryCount++;
1884 // Handle paging using skip (number of entries to skip from the
1885 // start) and top (number of entries to display)
1886 if (entryCount <= skip || entryCount > skip + top)
1887 {
1888 continue;
1889 }
1890
Jason M. Bills16428a12018-11-02 12:42:29 -07001891 std::string idStr;
Jason M. Billse85d6b12019-07-29 17:01:15 -07001892 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
Jason M. Billse1f26342018-07-18 12:12:00 -07001893 {
Jason M. Billse1f26342018-07-18 12:12:00 -07001894 continue;
1895 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001896
Jason M. Billse85d6b12019-07-29 17:01:15 -07001897 if (firstEntry)
1898 {
1899 firstEntry = false;
1900 }
1901
Jason M. Billse1f26342018-07-18 12:12:00 -07001902 logEntryArray.push_back({});
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001903 nlohmann::json& bmcJournalLogEntry = logEntryArray.back();
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001904 if (fillBMCJournalLogEntryJson(idStr, journal.get(),
1905 bmcJournalLogEntry) != 0)
Jason M. Billse1f26342018-07-18 12:12:00 -07001906 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001907 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07001908 return;
1909 }
1910 }
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001911 asyncResp->res.jsonValue["Members@odata.count"] = entryCount;
1912 if (skip + top < entryCount)
1913 {
1914 asyncResp->res.jsonValue["Members@odata.nextLink"] =
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001915 "/redfish/v1/Managers/bmc/LogServices/Journal/Entries?$skip=" +
Jason M. Bills193ad2f2018-09-26 15:08:52 -07001916 std::to_string(skip + top);
1917 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001918 }
1919};
1920
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001921class BMCJournalLogEntry : public Node
Jason M. Billse1f26342018-07-18 12:12:00 -07001922{
1923 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001924 BMCJournalLogEntry(App& app) :
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001925 Node(app, "/redfish/v1/Managers/bmc/LogServices/Journal/Entries/<str>/",
Jason M. Billse1f26342018-07-18 12:12:00 -07001926 std::string())
1927 {
1928 entityPrivileges = {
1929 {boost::beast::http::verb::get, {{"Login"}}},
1930 {boost::beast::http::verb::head, {{"Login"}}},
1931 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
1932 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
1933 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
1934 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
1935 }
1936
1937 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001938 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001939 const std::vector<std::string>& params) override
Jason M. Billse1f26342018-07-18 12:12:00 -07001940 {
1941 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
1942 if (params.size() != 1)
1943 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001944 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07001945 return;
1946 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001947 const std::string& entryID = params[0];
Jason M. Billse1f26342018-07-18 12:12:00 -07001948 // Convert the unique ID back to a timestamp to find the entry
Jason M. Billse1f26342018-07-18 12:12:00 -07001949 uint64_t ts = 0;
Ed Tanous271584a2019-07-09 16:24:22 -07001950 uint64_t index = 0;
Jason M. Bills16428a12018-11-02 12:42:29 -07001951 if (!getTimestampFromID(asyncResp->res, entryID, ts, index))
Jason M. Billse1f26342018-07-18 12:12:00 -07001952 {
Jason M. Bills16428a12018-11-02 12:42:29 -07001953 return;
Jason M. Billse1f26342018-07-18 12:12:00 -07001954 }
1955
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001956 sd_journal* journalTmp = nullptr;
Jason M. Billse1f26342018-07-18 12:12:00 -07001957 int ret = sd_journal_open(&journalTmp, SD_JOURNAL_LOCAL_ONLY);
1958 if (ret < 0)
1959 {
1960 BMCWEB_LOG_ERROR << "failed to open journal: " << strerror(-ret);
Jason M. Billsf12894f2018-10-09 12:45:45 -07001961 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07001962 return;
1963 }
1964 std::unique_ptr<sd_journal, decltype(&sd_journal_close)> journal(
1965 journalTmp, sd_journal_close);
1966 journalTmp = nullptr;
1967 // Go to the timestamp in the log and move to the entry at the index
Jason M. Billsaf07e3f2019-08-01 14:41:39 -07001968 // tracking the unique ID
1969 std::string idStr;
1970 bool firstEntry = true;
Jason M. Billse1f26342018-07-18 12:12:00 -07001971 ret = sd_journal_seek_realtime_usec(journal.get(), ts);
Manojkiran Eda2056b6d2020-05-28 08:57:36 +05301972 if (ret < 0)
1973 {
1974 BMCWEB_LOG_ERROR << "failed to seek to an entry in journal"
1975 << strerror(-ret);
1976 messages::internalError(asyncResp->res);
1977 return;
1978 }
Ed Tanous271584a2019-07-09 16:24:22 -07001979 for (uint64_t i = 0; i <= index; i++)
Jason M. Billse1f26342018-07-18 12:12:00 -07001980 {
1981 sd_journal_next(journal.get());
Jason M. Billsaf07e3f2019-08-01 14:41:39 -07001982 if (!getUniqueEntryID(journal.get(), idStr, firstEntry))
1983 {
1984 messages::internalError(asyncResp->res);
1985 return;
1986 }
1987 if (firstEntry)
1988 {
1989 firstEntry = false;
1990 }
Jason M. Billse1f26342018-07-18 12:12:00 -07001991 }
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001992 // Confirm that the entry ID matches what was requested
Jason M. Billsaf07e3f2019-08-01 14:41:39 -07001993 if (idStr != entryID)
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001994 {
1995 messages::resourceMissingAtURI(asyncResp->res, entryID);
1996 return;
1997 }
1998
1999 if (fillBMCJournalLogEntryJson(entryID, journal.get(),
2000 asyncResp->res.jsonValue) != 0)
Jason M. Billse1f26342018-07-18 12:12:00 -07002001 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002002 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07002003 return;
2004 }
2005 }
2006};
2007
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002008class BMCDumpService : public Node
raviteja-bc9bb6862020-02-03 11:53:32 -06002009{
2010 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002011 BMCDumpService(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002012 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/")
raviteja-bc9bb6862020-02-03 11:53:32 -06002013 {
2014 entityPrivileges = {
2015 {boost::beast::http::verb::get, {{"Login"}}},
2016 {boost::beast::http::verb::head, {{"Login"}}},
2017 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2018 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2019 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2020 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2021 }
2022
2023 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002024 void doGet(crow::Response& res, const crow::Request&,
2025 const std::vector<std::string>&) override
raviteja-bc9bb6862020-02-03 11:53:32 -06002026 {
2027 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2028
2029 asyncResp->res.jsonValue["@odata.id"] =
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002030 "/redfish/v1/Managers/bmc/LogServices/Dump";
raviteja-bc9bb6862020-02-03 11:53:32 -06002031 asyncResp->res.jsonValue["@odata.type"] =
2032 "#LogService.v1_1_0.LogService";
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002033 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2034 asyncResp->res.jsonValue["Description"] = "BMC Dump LogService";
2035 asyncResp->res.jsonValue["Id"] = "Dump";
raviteja-bc9bb6862020-02-03 11:53:32 -06002036 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
raviteja-bc9bb6862020-02-03 11:53:32 -06002037 asyncResp->res.jsonValue["Entries"] = {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002038 {"@odata.id", "/redfish/v1/Managers/bmc/LogServices/Dump/Entries"}};
2039 asyncResp->res.jsonValue["Actions"] = {
2040 {"#LogService.ClearLog",
2041 {{"target", "/redfish/v1/Managers/bmc/LogServices/Dump/"
2042 "Actions/LogService.ClearLog"}}},
2043 {"Oem",
2044 {{"#OemLogService.CollectDiagnosticData",
2045 {{"target",
2046 "/redfish/v1/Managers/bmc/LogServices/Dump/"
2047 "Actions/Oem/OemLogService.CollectDiagnosticData"}}}}}};
raviteja-bc9bb6862020-02-03 11:53:32 -06002048 }
2049};
2050
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002051class BMCDumpEntryCollection : public Node
raviteja-bc9bb6862020-02-03 11:53:32 -06002052{
2053 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002054 BMCDumpEntryCollection(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002055 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/")
raviteja-bc9bb6862020-02-03 11:53:32 -06002056 {
2057 entityPrivileges = {
2058 {boost::beast::http::verb::get, {{"Login"}}},
2059 {boost::beast::http::verb::head, {{"Login"}}},
2060 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2061 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2062 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2063 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2064 }
2065
2066 private:
2067 /**
2068 * Functions triggers appropriate requests on DBus
2069 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002070 void doGet(crow::Response& res, const crow::Request&,
2071 const std::vector<std::string>&) override
raviteja-bc9bb6862020-02-03 11:53:32 -06002072 {
2073 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2074
2075 asyncResp->res.jsonValue["@odata.type"] =
2076 "#LogEntryCollection.LogEntryCollection";
2077 asyncResp->res.jsonValue["@odata.id"] =
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002078 "/redfish/v1/Managers/bmc/LogServices/Dump/Entries";
2079 asyncResp->res.jsonValue["Name"] = "BMC Dump Entries";
raviteja-bc9bb6862020-02-03 11:53:32 -06002080 asyncResp->res.jsonValue["Description"] =
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002081 "Collection of BMC Dump Entries";
raviteja-bc9bb6862020-02-03 11:53:32 -06002082
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002083 getDumpEntryCollection(asyncResp, "BMC");
raviteja-bc9bb6862020-02-03 11:53:32 -06002084 }
2085};
2086
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002087class BMCDumpEntry : public Node
raviteja-bc9bb6862020-02-03 11:53:32 -06002088{
2089 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002090 BMCDumpEntry(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002091 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/Entries/<str>/",
raviteja-bc9bb6862020-02-03 11:53:32 -06002092 std::string())
2093 {
2094 entityPrivileges = {
2095 {boost::beast::http::verb::get, {{"Login"}}},
2096 {boost::beast::http::verb::head, {{"Login"}}},
2097 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2098 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2099 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2100 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2101 }
2102
2103 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002104 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002105 const std::vector<std::string>& params) override
raviteja-bc9bb6862020-02-03 11:53:32 -06002106 {
2107 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2108 if (params.size() != 1)
2109 {
2110 messages::internalError(asyncResp->res);
2111 return;
2112 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002113 getDumpEntryById(asyncResp, params[0], "BMC");
raviteja-bc9bb6862020-02-03 11:53:32 -06002114 }
2115
Ed Tanouscb13a392020-07-25 19:02:03 +00002116 void doDelete(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002117 const std::vector<std::string>& params) override
raviteja-bc9bb6862020-02-03 11:53:32 -06002118 {
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002119 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
raviteja-bc9bb6862020-02-03 11:53:32 -06002120 if (params.size() != 1)
2121 {
2122 messages::internalError(asyncResp->res);
2123 return;
2124 }
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002125 deleteDumpEntry(asyncResp->res, params[0]);
2126 }
2127};
raviteja-bc9bb6862020-02-03 11:53:32 -06002128
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002129class BMCDumpCreate : public Node
2130{
2131 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002132 BMCDumpCreate(App& app) :
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002133 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/"
2134 "Actions/Oem/"
2135 "OemLogService.CollectDiagnosticData/")
2136 {
2137 entityPrivileges = {
2138 {boost::beast::http::verb::get, {{"Login"}}},
2139 {boost::beast::http::verb::head, {{"Login"}}},
2140 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2141 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2142 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2143 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2144 }
2145
2146 private:
2147 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00002148 const std::vector<std::string>&) override
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002149 {
2150 createDump(res, req, "BMC");
2151 }
2152};
2153
Asmitha Karunanithif71882f2020-05-07 06:21:47 -05002154class BMCDumpEntryDownload : public Node
2155{
2156 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002157 BMCDumpEntryDownload(App& app) :
Asmitha Karunanithif71882f2020-05-07 06:21:47 -05002158 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/attachment/<str>/",
2159 std::string())
2160 {
2161 entityPrivileges = {
2162 {boost::beast::http::verb::get, {{"Login"}}},
2163 {boost::beast::http::verb::head, {{"Login"}}},
2164 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2165 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2166 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2167 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2168 }
2169
2170 private:
2171 void doGet(crow::Response& res, const crow::Request& req,
2172 const std::vector<std::string>& params) override
2173 {
2174 if (params.size() != 1)
2175 {
2176 messages::internalError(res);
2177 return;
2178 }
2179 const std::string& entryID = params[0];
2180 crow::obmc_dump::handleDumpOffloadUrl(req, res, entryID);
2181 }
2182};
2183
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002184class BMCDumpClear : public Node
2185{
2186 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002187 BMCDumpClear(App& app) :
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002188 Node(app, "/redfish/v1/Managers/bmc/LogServices/Dump/"
2189 "Actions/"
2190 "LogService.ClearLog/")
2191 {
2192 entityPrivileges = {
2193 {boost::beast::http::verb::get, {{"Login"}}},
2194 {boost::beast::http::verb::head, {{"Login"}}},
2195 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2196 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2197 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2198 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2199 }
2200
2201 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002202 void doPost(crow::Response& res, const crow::Request&,
2203 const std::vector<std::string>&) override
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002204 {
2205 clearDump(res, "xyz.openbmc_project.Dump.Entry.BMC");
2206 }
2207};
2208
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002209class SystemDumpService : public Node
2210{
2211 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002212 SystemDumpService(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002213 Node(app, "/redfish/v1/Systems/system/LogServices/Dump/")
2214 {
2215 entityPrivileges = {
2216 {boost::beast::http::verb::get, {{"Login"}}},
2217 {boost::beast::http::verb::head, {{"Login"}}},
2218 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2219 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2220 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2221 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2222 }
raviteja-bc9bb6862020-02-03 11:53:32 -06002223
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002224 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002225 void doGet(crow::Response& res, const crow::Request&,
2226 const std::vector<std::string>&) override
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002227 {
2228 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
raviteja-bc9bb6862020-02-03 11:53:32 -06002229
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002230 asyncResp->res.jsonValue["@odata.id"] =
2231 "/redfish/v1/Systems/system/LogServices/Dump";
2232 asyncResp->res.jsonValue["@odata.type"] =
2233 "#LogService.v1_1_0.LogService";
2234 asyncResp->res.jsonValue["Name"] = "Dump LogService";
2235 asyncResp->res.jsonValue["Description"] = "System Dump LogService";
2236 asyncResp->res.jsonValue["Id"] = "Dump";
2237 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
2238 asyncResp->res.jsonValue["Entries"] = {
2239 {"@odata.id",
2240 "/redfish/v1/Systems/system/LogServices/Dump/Entries"}};
2241 asyncResp->res.jsonValue["Actions"] = {
2242 {"#LogService.ClearLog",
2243 {{"target", "/redfish/v1/Systems/system/LogServices/Dump/Actions/"
2244 "LogService.ClearLog"}}},
2245 {"Oem",
2246 {{"#OemLogService.CollectDiagnosticData",
2247 {{"target",
2248 "/redfish/v1/Systems/system/LogServices/Dump/Actions/Oem/"
2249 "OemLogService.CollectDiagnosticData"}}}}}};
2250 }
2251};
2252
2253class SystemDumpEntryCollection : public Node
2254{
2255 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002256 SystemDumpEntryCollection(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002257 Node(app, "/redfish/v1/Systems/system/LogServices/Dump/Entries/")
2258 {
2259 entityPrivileges = {
2260 {boost::beast::http::verb::get, {{"Login"}}},
2261 {boost::beast::http::verb::head, {{"Login"}}},
2262 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2263 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2264 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2265 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2266 }
2267
2268 private:
2269 /**
2270 * Functions triggers appropriate requests on DBus
2271 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002272 void doGet(crow::Response& res, const crow::Request&,
2273 const std::vector<std::string>&) override
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002274 {
2275 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2276
2277 asyncResp->res.jsonValue["@odata.type"] =
2278 "#LogEntryCollection.LogEntryCollection";
2279 asyncResp->res.jsonValue["@odata.id"] =
2280 "/redfish/v1/Systems/system/LogServices/Dump/Entries";
2281 asyncResp->res.jsonValue["Name"] = "System Dump Entries";
2282 asyncResp->res.jsonValue["Description"] =
2283 "Collection of System Dump Entries";
2284
2285 getDumpEntryCollection(asyncResp, "System");
2286 }
2287};
2288
2289class SystemDumpEntry : public Node
2290{
2291 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002292 SystemDumpEntry(App& app) :
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002293 Node(app, "/redfish/v1/Systems/system/LogServices/Dump/Entries/<str>/",
2294 std::string())
2295 {
2296 entityPrivileges = {
2297 {boost::beast::http::verb::get, {{"Login"}}},
2298 {boost::beast::http::verb::head, {{"Login"}}},
2299 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2300 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2301 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2302 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2303 }
2304
2305 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002306 void doGet(crow::Response& res, const crow::Request&,
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002307 const std::vector<std::string>& params) override
2308 {
2309 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2310 if (params.size() != 1)
2311 {
2312 messages::internalError(asyncResp->res);
2313 return;
2314 }
2315 getDumpEntryById(asyncResp, params[0], "System");
2316 }
2317
Ed Tanouscb13a392020-07-25 19:02:03 +00002318 void doDelete(crow::Response& res, const crow::Request&,
Asmitha Karunanithi5cb1dd22020-05-07 04:35:02 -05002319 const std::vector<std::string>& params) override
2320 {
2321 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2322 if (params.size() != 1)
2323 {
2324 messages::internalError(asyncResp->res);
2325 return;
2326 }
2327 deleteDumpEntry(asyncResp->res, params[0]);
raviteja-bc9bb6862020-02-03 11:53:32 -06002328 }
2329};
2330
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002331class SystemDumpCreate : public Node
2332{
2333 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002334 SystemDumpCreate(App& app) :
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002335 Node(app, "/redfish/v1/Systems/system/LogServices/Dump/"
2336 "Actions/Oem/"
2337 "OemLogService.CollectDiagnosticData/")
2338 {
2339 entityPrivileges = {
2340 {boost::beast::http::verb::get, {{"Login"}}},
2341 {boost::beast::http::verb::head, {{"Login"}}},
2342 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2343 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2344 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2345 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2346 }
2347
2348 private:
2349 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00002350 const std::vector<std::string>&) override
Asmitha Karunanithia43be802020-05-07 05:05:36 -05002351 {
2352 createDump(res, req, "System");
2353 }
2354};
2355
raviteja-b06578432020-02-03 12:50:42 -06002356class SystemDumpEntryDownload : public Node
2357{
2358 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002359 SystemDumpEntryDownload(App& app) :
raviteja-b06578432020-02-03 12:50:42 -06002360 Node(app,
Asmitha Karunanithif71882f2020-05-07 06:21:47 -05002361 "/redfish/v1/Systems/system/LogServices/Dump/attachment/<str>/",
raviteja-b06578432020-02-03 12:50:42 -06002362 std::string())
2363 {
2364 entityPrivileges = {
2365 {boost::beast::http::verb::get, {{"Login"}}},
2366 {boost::beast::http::verb::head, {{"Login"}}},
Asmitha Karunanithif71882f2020-05-07 06:21:47 -05002367 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2368 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2369 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
raviteja-b06578432020-02-03 12:50:42 -06002370 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2371 }
2372
2373 private:
Asmitha Karunanithif71882f2020-05-07 06:21:47 -05002374 void doGet(crow::Response& res, const crow::Request& req,
2375 const std::vector<std::string>& params) override
raviteja-b06578432020-02-03 12:50:42 -06002376 {
2377 if (params.size() != 1)
2378 {
2379 messages::internalError(res);
2380 return;
2381 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002382 const std::string& entryID = params[0];
raviteja-b06578432020-02-03 12:50:42 -06002383 crow::obmc_dump::handleDumpOffloadUrl(req, res, entryID);
2384 }
2385};
2386
raviteja-b013487e2020-03-03 03:20:48 -06002387class SystemDumpClear : public Node
2388{
2389 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002390 SystemDumpClear(App& app) :
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002391 Node(app, "/redfish/v1/Systems/system/LogServices/Dump/"
raviteja-b013487e2020-03-03 03:20:48 -06002392 "Actions/"
2393 "LogService.ClearLog/")
2394 {
2395 entityPrivileges = {
2396 {boost::beast::http::verb::get, {{"Login"}}},
2397 {boost::beast::http::verb::head, {{"Login"}}},
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002398 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2399 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2400 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
raviteja-b013487e2020-03-03 03:20:48 -06002401 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2402 }
2403
2404 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002405 void doPost(crow::Response& res, const crow::Request&,
2406 const std::vector<std::string>&) override
raviteja-b013487e2020-03-03 03:20:48 -06002407 {
Asmitha Karunanithi80319af2020-05-07 05:30:21 -05002408 clearDump(res, "xyz.openbmc_project.Dump.Entry.System");
raviteja-b013487e2020-03-03 03:20:48 -06002409 }
2410};
2411
Jason M. Bills424c4172019-03-21 13:50:33 -07002412class CrashdumpService : public Node
Jason M. Billse1f26342018-07-18 12:12:00 -07002413{
2414 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002415 CrashdumpService(App& app) :
Jason M. Bills424c4172019-03-21 13:50:33 -07002416 Node(app, "/redfish/v1/Systems/system/LogServices/Crashdump/")
Ed Tanous1da66f72018-07-27 16:13:37 -07002417 {
AppaRao Puli39460282020-04-07 17:03:04 +05302418 // Note: Deviated from redfish privilege registry for GET & HEAD
2419 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002420 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302421 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2422 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
Jason M. Billse1f26342018-07-18 12:12:00 -07002423 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2424 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2425 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2426 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07002427 }
2428
2429 private:
2430 /**
2431 * Functions triggers appropriate requests on DBus
2432 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002433 void doGet(crow::Response& res, const crow::Request&,
2434 const std::vector<std::string>&) override
Ed Tanous1da66f72018-07-27 16:13:37 -07002435 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002436 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002437 // Copy over the static data to include the entries added by SubRoute
Ed Tanous0f74e642018-11-12 15:17:05 -08002438 asyncResp->res.jsonValue["@odata.id"] =
Jason M. Bills424c4172019-03-21 13:50:33 -07002439 "/redfish/v1/Systems/system/LogServices/Crashdump";
Jason M. Billse1f26342018-07-18 12:12:00 -07002440 asyncResp->res.jsonValue["@odata.type"] =
2441 "#LogService.v1_1_0.LogService";
Gunnar Mills4f50ae42020-02-06 15:29:57 -06002442 asyncResp->res.jsonValue["Name"] = "Open BMC Oem Crashdump Service";
2443 asyncResp->res.jsonValue["Description"] = "Oem Crashdump Service";
2444 asyncResp->res.jsonValue["Id"] = "Oem Crashdump";
Jason M. Billse1f26342018-07-18 12:12:00 -07002445 asyncResp->res.jsonValue["OverWritePolicy"] = "WrapsWhenFull";
2446 asyncResp->res.jsonValue["MaxNumberOfRecords"] = 3;
Jason M. Billscd50aa42019-02-12 17:09:02 -08002447 asyncResp->res.jsonValue["Entries"] = {
2448 {"@odata.id",
Jason M. Bills424c4172019-03-21 13:50:33 -07002449 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries"}};
Jason M. Billse1f26342018-07-18 12:12:00 -07002450 asyncResp->res.jsonValue["Actions"] = {
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002451 {"#LogService.ClearLog",
2452 {{"target", "/redfish/v1/Systems/system/LogServices/Crashdump/"
2453 "Actions/LogService.ClearLog"}}},
Ed Tanous1da66f72018-07-27 16:13:37 -07002454 {"Oem",
Jason M. Bills424c4172019-03-21 13:50:33 -07002455 {{"#Crashdump.OnDemand",
2456 {{"target", "/redfish/v1/Systems/system/LogServices/Crashdump/"
Kenny L. Ku6eda7682020-06-19 09:48:36 -07002457 "Actions/Oem/Crashdump.OnDemand"}}},
2458 {"#Crashdump.Telemetry",
2459 {{"target", "/redfish/v1/Systems/system/LogServices/Crashdump/"
2460 "Actions/Oem/Crashdump.Telemetry"}}}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07002461
2462#ifdef BMCWEB_ENABLE_REDFISH_RAW_PECI
Jason M. Billse1f26342018-07-18 12:12:00 -07002463 asyncResp->res.jsonValue["Actions"]["Oem"].push_back(
Jason M. Bills424c4172019-03-21 13:50:33 -07002464 {"#Crashdump.SendRawPeci",
Anthony Wilson08a4e4b2019-04-12 08:23:05 -05002465 {{"target", "/redfish/v1/Systems/system/LogServices/Crashdump/"
2466 "Actions/Oem/Crashdump.SendRawPeci"}}});
Ed Tanous1da66f72018-07-27 16:13:37 -07002467#endif
Ed Tanous1da66f72018-07-27 16:13:37 -07002468 }
2469};
2470
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002471class CrashdumpClear : public Node
2472{
2473 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002474 CrashdumpClear(App& app) :
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002475 Node(app, "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/"
2476 "LogService.ClearLog/")
2477 {
AppaRao Puli39460282020-04-07 17:03:04 +05302478 // Note: Deviated from redfish privilege registry for GET & HEAD
2479 // method for security reasons.
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002480 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302481 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2482 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002483 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2484 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2485 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2486 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
2487 }
2488
2489 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002490 void doPost(crow::Response& res, const crow::Request&,
2491 const std::vector<std::string>&) override
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002492 {
2493 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2494
2495 crow::connections::systemBus->async_method_call(
2496 [asyncResp](const boost::system::error_code ec,
Ed Tanouscb13a392020-07-25 19:02:03 +00002497 const std::string&) {
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002498 if (ec)
2499 {
2500 messages::internalError(asyncResp->res);
2501 return;
2502 }
2503 messages::success(asyncResp->res);
2504 },
2505 crashdumpObject, crashdumpPath, deleteAllInterface, "DeleteAll");
2506 }
2507};
2508
Jason M. Billse855dd22019-10-08 11:37:48 -07002509static void logCrashdumpEntry(std::shared_ptr<AsyncResp> asyncResp,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002510 const std::string& logID,
2511 nlohmann::json& logEntryJson)
Jason M. Billse855dd22019-10-08 11:37:48 -07002512{
Johnathan Mantey043a0532020-03-10 17:15:28 -07002513 auto getStoredLogCallback =
2514 [asyncResp, logID, &logEntryJson](
2515 const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002516 const std::vector<std::pair<std::string, VariantType>>& params) {
Johnathan Mantey043a0532020-03-10 17:15:28 -07002517 if (ec)
Jason M. Bills1ddcf012019-11-26 14:59:21 -08002518 {
Johnathan Mantey043a0532020-03-10 17:15:28 -07002519 BMCWEB_LOG_DEBUG << "failed to get log ec: " << ec.message();
2520 if (ec.value() ==
2521 boost::system::linux_error::bad_request_descriptor)
2522 {
2523 messages::resourceNotFound(asyncResp->res, "LogEntry",
2524 logID);
2525 }
2526 else
2527 {
2528 messages::internalError(asyncResp->res);
2529 }
2530 return;
Jason M. Bills1ddcf012019-11-26 14:59:21 -08002531 }
Jason M. Billse855dd22019-10-08 11:37:48 -07002532
Johnathan Mantey043a0532020-03-10 17:15:28 -07002533 std::string timestamp{};
2534 std::string filename{};
2535 std::string logfile{};
2536 ParseCrashdumpParameters(params, filename, timestamp, logfile);
2537
2538 if (filename.empty() || timestamp.empty())
2539 {
2540 messages::resourceMissingAtURI(asyncResp->res, logID);
2541 return;
2542 }
2543
2544 std::string crashdumpURI =
2545 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/" +
2546 logID + "/" + filename;
2547 logEntryJson = {{"@odata.type", "#LogEntry.v1_4_0.LogEntry"},
2548 {"@odata.id", "/redfish/v1/Systems/system/"
2549 "LogServices/Crashdump/Entries/" +
2550 logID},
2551 {"Name", "CPU Crashdump"},
2552 {"Id", logID},
2553 {"EntryType", "Oem"},
2554 {"OemRecordFormat", "Crashdump URI"},
2555 {"Message", std::move(crashdumpURI)},
2556 {"Created", std::move(timestamp)}};
2557 };
Jason M. Billse855dd22019-10-08 11:37:48 -07002558 crow::connections::systemBus->async_method_call(
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002559 std::move(getStoredLogCallback), crashdumpObject,
2560 crashdumpPath + std::string("/") + logID,
Johnathan Mantey043a0532020-03-10 17:15:28 -07002561 "org.freedesktop.DBus.Properties", "GetAll", crashdumpInterface);
Jason M. Billse855dd22019-10-08 11:37:48 -07002562}
2563
Jason M. Bills424c4172019-03-21 13:50:33 -07002564class CrashdumpEntryCollection : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -07002565{
2566 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002567 CrashdumpEntryCollection(App& app) :
Jason M. Bills424c4172019-03-21 13:50:33 -07002568 Node(app, "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/")
Ed Tanous1da66f72018-07-27 16:13:37 -07002569 {
AppaRao Puli39460282020-04-07 17:03:04 +05302570 // Note: Deviated from redfish privilege registry for GET & HEAD
2571 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002572 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302573 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2574 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
Jason M. Billse1f26342018-07-18 12:12:00 -07002575 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2576 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2577 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2578 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07002579 }
2580
2581 private:
2582 /**
2583 * Functions triggers appropriate requests on DBus
2584 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002585 void doGet(crow::Response& res, const crow::Request&,
2586 const std::vector<std::string>&) override
Ed Tanous1da66f72018-07-27 16:13:37 -07002587 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002588 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002589 // Collections don't include the static data added by SubRoute because
2590 // it has a duplicate entry for members
Jason M. Billse1f26342018-07-18 12:12:00 -07002591 auto getLogEntriesCallback = [asyncResp](
2592 const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002593 const std::vector<std::string>& resp) {
Jason M. Billse1f26342018-07-18 12:12:00 -07002594 if (ec)
2595 {
2596 if (ec.value() !=
2597 boost::system::errc::no_such_file_or_directory)
Ed Tanous1da66f72018-07-27 16:13:37 -07002598 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002599 BMCWEB_LOG_DEBUG << "failed to get entries ec: "
2600 << ec.message();
Jason M. Billsf12894f2018-10-09 12:45:45 -07002601 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07002602 return;
Ed Tanous1da66f72018-07-27 16:13:37 -07002603 }
Jason M. Billse1f26342018-07-18 12:12:00 -07002604 }
2605 asyncResp->res.jsonValue["@odata.type"] =
2606 "#LogEntryCollection.LogEntryCollection";
Ed Tanous0f74e642018-11-12 15:17:05 -08002607 asyncResp->res.jsonValue["@odata.id"] =
Jason M. Bills424c4172019-03-21 13:50:33 -07002608 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries";
Jason M. Bills424c4172019-03-21 13:50:33 -07002609 asyncResp->res.jsonValue["Name"] = "Open BMC Crashdump Entries";
Jason M. Billse1f26342018-07-18 12:12:00 -07002610 asyncResp->res.jsonValue["Description"] =
Jason M. Bills424c4172019-03-21 13:50:33 -07002611 "Collection of Crashdump Entries";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002612 nlohmann::json& logEntryArray = asyncResp->res.jsonValue["Members"];
Jason M. Billse1f26342018-07-18 12:12:00 -07002613 logEntryArray = nlohmann::json::array();
Jason M. Billse855dd22019-10-08 11:37:48 -07002614 std::vector<std::string> logIDs;
2615 // Get the list of log entries and build up an empty array big
2616 // enough to hold them
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002617 for (const std::string& objpath : resp)
Jason M. Billse1f26342018-07-18 12:12:00 -07002618 {
Jason M. Billse855dd22019-10-08 11:37:48 -07002619 // Get the log ID
Jason M. Billse1f26342018-07-18 12:12:00 -07002620 std::size_t lastPos = objpath.rfind("/");
Jason M. Billse855dd22019-10-08 11:37:48 -07002621 if (lastPos == std::string::npos)
Jason M. Billse1f26342018-07-18 12:12:00 -07002622 {
Jason M. Billse855dd22019-10-08 11:37:48 -07002623 continue;
Jason M. Billse1f26342018-07-18 12:12:00 -07002624 }
Jason M. Billse855dd22019-10-08 11:37:48 -07002625 logIDs.emplace_back(objpath.substr(lastPos + 1));
2626
2627 // Add a space for the log entry to the array
2628 logEntryArray.push_back({});
2629 }
2630 // Now go through and set up async calls to fill in the entries
2631 size_t index = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002632 for (const std::string& logID : logIDs)
Jason M. Billse855dd22019-10-08 11:37:48 -07002633 {
2634 // Add the log entry to the array
2635 logCrashdumpEntry(asyncResp, logID, logEntryArray[index++]);
Jason M. Billse1f26342018-07-18 12:12:00 -07002636 }
2637 asyncResp->res.jsonValue["Members@odata.count"] =
2638 logEntryArray.size();
2639 };
Ed Tanous1da66f72018-07-27 16:13:37 -07002640 crow::connections::systemBus->async_method_call(
2641 std::move(getLogEntriesCallback),
2642 "xyz.openbmc_project.ObjectMapper",
2643 "/xyz/openbmc_project/object_mapper",
2644 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "", 0,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002645 std::array<const char*, 1>{crashdumpInterface});
Ed Tanous1da66f72018-07-27 16:13:37 -07002646 }
2647};
2648
Jason M. Bills424c4172019-03-21 13:50:33 -07002649class CrashdumpEntry : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -07002650{
2651 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002652 CrashdumpEntry(App& app) :
Jason M. Billsd53dd412019-02-12 17:16:22 -08002653 Node(app,
Jason M. Bills424c4172019-03-21 13:50:33 -07002654 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/",
Ed Tanous1da66f72018-07-27 16:13:37 -07002655 std::string())
2656 {
AppaRao Puli39460282020-04-07 17:03:04 +05302657 // Note: Deviated from redfish privilege registry for GET & HEAD
2658 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002659 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302660 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2661 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
Jason M. Billse1f26342018-07-18 12:12:00 -07002662 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2663 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2664 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2665 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07002666 }
2667
2668 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002669 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002670 const std::vector<std::string>& params) override
Ed Tanous1da66f72018-07-27 16:13:37 -07002671 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002672 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002673 if (params.size() != 1)
2674 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07002675 messages::internalError(asyncResp->res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002676 return;
2677 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002678 const std::string& logID = params[0];
Jason M. Billse855dd22019-10-08 11:37:48 -07002679 logCrashdumpEntry(asyncResp, logID, asyncResp->res.jsonValue);
2680 }
2681};
2682
2683class CrashdumpFile : public Node
2684{
2685 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002686 CrashdumpFile(App& app) :
Jason M. Billse855dd22019-10-08 11:37:48 -07002687 Node(app,
2688 "/redfish/v1/Systems/system/LogServices/Crashdump/Entries/<str>/"
2689 "<str>/",
2690 std::string(), std::string())
2691 {
AppaRao Puli39460282020-04-07 17:03:04 +05302692 // Note: Deviated from redfish privilege registry for GET & HEAD
2693 // method for security reasons.
Jason M. Billse855dd22019-10-08 11:37:48 -07002694 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302695 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2696 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
Jason M. Billse855dd22019-10-08 11:37:48 -07002697 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
2698 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
2699 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
2700 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
2701 }
2702
2703 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00002704 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002705 const std::vector<std::string>& params) override
Jason M. Billse855dd22019-10-08 11:37:48 -07002706 {
2707 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2708 if (params.size() != 2)
2709 {
2710 messages::internalError(asyncResp->res);
2711 return;
2712 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002713 const std::string& logID = params[0];
2714 const std::string& fileName = params[1];
Jason M. Billse855dd22019-10-08 11:37:48 -07002715
Johnathan Mantey043a0532020-03-10 17:15:28 -07002716 auto getStoredLogCallback =
2717 [asyncResp, logID, fileName](
2718 const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002719 const std::vector<std::pair<std::string, VariantType>>& resp) {
Johnathan Mantey043a0532020-03-10 17:15:28 -07002720 if (ec)
2721 {
2722 BMCWEB_LOG_DEBUG << "failed to get log ec: "
2723 << ec.message();
2724 messages::internalError(asyncResp->res);
2725 return;
2726 }
Jason M. Billse855dd22019-10-08 11:37:48 -07002727
Johnathan Mantey043a0532020-03-10 17:15:28 -07002728 std::string dbusFilename{};
2729 std::string dbusTimestamp{};
2730 std::string dbusFilepath{};
Jason M. Billse855dd22019-10-08 11:37:48 -07002731
Johnathan Mantey043a0532020-03-10 17:15:28 -07002732 ParseCrashdumpParameters(resp, dbusFilename, dbusTimestamp,
2733 dbusFilepath);
2734
2735 if (dbusFilename.empty() || dbusTimestamp.empty() ||
2736 dbusFilepath.empty())
2737 {
2738 messages::resourceMissingAtURI(asyncResp->res, fileName);
2739 return;
2740 }
2741
2742 // Verify the file name parameter is correct
2743 if (fileName != dbusFilename)
2744 {
2745 messages::resourceMissingAtURI(asyncResp->res, fileName);
2746 return;
2747 }
2748
2749 if (!std::filesystem::exists(dbusFilepath))
2750 {
2751 messages::resourceMissingAtURI(asyncResp->res, fileName);
2752 return;
2753 }
2754 std::ifstream ifs(dbusFilepath, std::ios::in |
2755 std::ios::binary |
2756 std::ios::ate);
2757 std::ifstream::pos_type fileSize = ifs.tellg();
2758 if (fileSize < 0)
2759 {
2760 messages::generalError(asyncResp->res);
2761 return;
2762 }
2763 ifs.seekg(0, std::ios::beg);
2764
2765 auto crashData = std::make_unique<char[]>(
2766 static_cast<unsigned int>(fileSize));
2767
2768 ifs.read(crashData.get(), static_cast<int>(fileSize));
2769
2770 // The cast to std::string is intentional in order to use the
2771 // assign() that applies move mechanics
2772 asyncResp->res.body().assign(
2773 static_cast<std::string>(crashData.get()));
2774
2775 // Configure this to be a file download when accessed from
2776 // a browser
2777 asyncResp->res.addHeader("Content-Disposition", "attachment");
2778 };
Ed Tanous1da66f72018-07-27 16:13:37 -07002779 crow::connections::systemBus->async_method_call(
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002780 std::move(getStoredLogCallback), crashdumpObject,
2781 crashdumpPath + std::string("/") + logID,
Johnathan Mantey043a0532020-03-10 17:15:28 -07002782 "org.freedesktop.DBus.Properties", "GetAll", crashdumpInterface);
Ed Tanous1da66f72018-07-27 16:13:37 -07002783 }
2784};
2785
Jason M. Bills424c4172019-03-21 13:50:33 -07002786class OnDemandCrashdump : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -07002787{
2788 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002789 OnDemandCrashdump(App& app) :
Jason M. Bills424c4172019-03-21 13:50:33 -07002790 Node(app,
2791 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/Oem/"
2792 "Crashdump.OnDemand/")
Ed Tanous1da66f72018-07-27 16:13:37 -07002793 {
AppaRao Puli39460282020-04-07 17:03:04 +05302794 // Note: Deviated from redfish privilege registry for GET & HEAD
2795 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002796 entityPrivileges = {
AppaRao Puli39460282020-04-07 17:03:04 +05302797 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2798 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
2799 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2800 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2801 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2802 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Ed Tanous1da66f72018-07-27 16:13:37 -07002803 }
2804
2805 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002806 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00002807 const std::vector<std::string>&) override
Ed Tanous1da66f72018-07-27 16:13:37 -07002808 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002809 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002810
James Feistfe306722020-03-12 16:32:08 -07002811 auto generateonDemandLogCallback = [asyncResp,
2812 req](const boost::system::error_code
2813 ec,
Ed Tanouscb13a392020-07-25 19:02:03 +00002814 const std::string&) {
James Feist46229572020-02-19 15:11:58 -08002815 if (ec)
2816 {
2817 if (ec.value() == boost::system::errc::operation_not_supported)
Ed Tanous1da66f72018-07-27 16:13:37 -07002818 {
James Feist46229572020-02-19 15:11:58 -08002819 messages::resourceInStandby(asyncResp->res);
Ed Tanous1da66f72018-07-27 16:13:37 -07002820 }
James Feist46229572020-02-19 15:11:58 -08002821 else if (ec.value() ==
2822 boost::system::errc::device_or_resource_busy)
2823 {
2824 messages::serviceTemporarilyUnavailable(asyncResp->res,
2825 "60");
2826 }
2827 else
2828 {
2829 messages::internalError(asyncResp->res);
2830 }
2831 return;
2832 }
2833 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002834 [](boost::system::error_code err, sdbusplus::message::message&,
2835 const std::shared_ptr<task::TaskData>& taskData) {
James Feist66afe4f2020-02-24 13:09:58 -08002836 if (!err)
2837 {
James Feiste5d50062020-05-11 17:29:00 -07002838 taskData->messages.emplace_back(
2839 messages::taskCompletedOK(
2840 std::to_string(taskData->index)));
James Feist831d6b02020-03-12 16:31:30 -07002841 taskData->state = "Completed";
James Feist66afe4f2020-02-24 13:09:58 -08002842 }
James Feist32898ce2020-03-10 16:16:52 -07002843 return task::completed;
James Feist66afe4f2020-02-24 13:09:58 -08002844 },
James Feist46229572020-02-19 15:11:58 -08002845 "type='signal',interface='org.freedesktop.DBus.Properties',"
2846 "member='PropertiesChanged',arg0namespace='com.intel."
2847 "crashdump'");
2848 task->startTimer(std::chrono::minutes(5));
2849 task->populateResp(asyncResp->res);
James Feistfe306722020-03-12 16:32:08 -07002850 task->payload.emplace(req);
James Feist46229572020-02-19 15:11:58 -08002851 };
Ed Tanous1da66f72018-07-27 16:13:37 -07002852 crow::connections::systemBus->async_method_call(
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002853 std::move(generateonDemandLogCallback), crashdumpObject,
2854 crashdumpPath, crashdumpOnDemandInterface, "GenerateOnDemandLog");
Ed Tanous1da66f72018-07-27 16:13:37 -07002855 }
2856};
2857
Kenny L. Ku6eda7682020-06-19 09:48:36 -07002858class TelemetryCrashdump : public Node
2859{
2860 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002861 TelemetryCrashdump(App& app) :
Kenny L. Ku6eda7682020-06-19 09:48:36 -07002862 Node(app,
2863 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/Oem/"
2864 "Crashdump.Telemetry/")
2865 {
2866 // Note: Deviated from redfish privilege registry for GET & HEAD
2867 // method for security reasons.
2868 entityPrivileges = {
2869 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2870 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
2871 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2872 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2873 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2874 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
2875 }
2876
2877 private:
2878 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00002879 const std::vector<std::string>&) override
Kenny L. Ku6eda7682020-06-19 09:48:36 -07002880 {
2881 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
2882
2883 auto generateTelemetryLogCallback = [asyncResp, req](
2884 const boost::system::error_code
2885 ec,
Ed Tanouscb13a392020-07-25 19:02:03 +00002886 const std::string&) {
Kenny L. Ku6eda7682020-06-19 09:48:36 -07002887 if (ec)
2888 {
2889 if (ec.value() == boost::system::errc::operation_not_supported)
2890 {
2891 messages::resourceInStandby(asyncResp->res);
2892 }
2893 else if (ec.value() ==
2894 boost::system::errc::device_or_resource_busy)
2895 {
2896 messages::serviceTemporarilyUnavailable(asyncResp->res,
2897 "60");
2898 }
2899 else
2900 {
2901 messages::internalError(asyncResp->res);
2902 }
2903 return;
2904 }
2905 std::shared_ptr<task::TaskData> task = task::TaskData::createTask(
2906 [](boost::system::error_code err, sdbusplus::message::message&,
2907 const std::shared_ptr<task::TaskData>& taskData) {
2908 if (!err)
2909 {
2910 taskData->messages.emplace_back(
2911 messages::taskCompletedOK(
2912 std::to_string(taskData->index)));
2913 taskData->state = "Completed";
2914 }
2915 return task::completed;
2916 },
2917 "type='signal',interface='org.freedesktop.DBus.Properties',"
2918 "member='PropertiesChanged',arg0namespace='com.intel."
2919 "crashdump'");
2920 task->startTimer(std::chrono::minutes(5));
2921 task->populateResp(asyncResp->res);
2922 task->payload.emplace(req);
2923 };
2924 crow::connections::systemBus->async_method_call(
2925 std::move(generateTelemetryLogCallback), crashdumpObject,
2926 crashdumpPath, crashdumpTelemetryInterface, "GenerateTelemetryLog");
2927 }
2928};
2929
Jason M. Billse1f26342018-07-18 12:12:00 -07002930class SendRawPECI : public Node
Ed Tanous1da66f72018-07-27 16:13:37 -07002931{
2932 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07002933 SendRawPECI(App& app) :
Jason M. Bills424c4172019-03-21 13:50:33 -07002934 Node(app,
2935 "/redfish/v1/Systems/system/LogServices/Crashdump/Actions/Oem/"
2936 "Crashdump.SendRawPeci/")
Ed Tanous1da66f72018-07-27 16:13:37 -07002937 {
AppaRao Puli39460282020-04-07 17:03:04 +05302938 // Note: Deviated from redfish privilege registry for GET & HEAD
2939 // method for security reasons.
Ed Tanous1da66f72018-07-27 16:13:37 -07002940 entityPrivileges = {
2941 {boost::beast::http::verb::get, {{"ConfigureComponents"}}},
2942 {boost::beast::http::verb::head, {{"ConfigureComponents"}}},
2943 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2944 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2945 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2946 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
2947 }
2948
2949 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002950 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00002951 const std::vector<std::string>&) override
Ed Tanous1da66f72018-07-27 16:13:37 -07002952 {
Jason M. Billse1f26342018-07-18 12:12:00 -07002953 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002954 std::vector<std::vector<uint8_t>> peciCommands;
Ed Tanousb1556422018-10-16 14:09:17 -07002955
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002956 if (!json_util::readJson(req, res, "PECICommands", peciCommands))
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002957 {
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002958 return;
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002959 }
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002960 uint32_t idx = 0;
2961 for (auto const& cmd : peciCommands)
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002962 {
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002963 if (cmd.size() < 3)
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002964 {
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002965 std::string s("[");
2966 for (auto const& val : cmd)
2967 {
2968 if (val != *cmd.begin())
2969 {
2970 s += ",";
2971 }
2972 s += std::to_string(val);
2973 }
2974 s += "]";
2975 messages::actionParameterValueFormatError(
2976 res, s, "PECICommands[" + std::to_string(idx) + "]",
2977 "SendRawPeci");
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002978 return;
2979 }
Karthick Sundarrajanf0b6ae02020-01-17 13:32:58 -08002980 idx++;
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002981 }
Ed Tanous1da66f72018-07-27 16:13:37 -07002982 // Callback to return the Raw PECI response
Jason M. Billse1f26342018-07-18 12:12:00 -07002983 auto sendRawPECICallback =
2984 [asyncResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05002985 const std::vector<std::vector<uint8_t>>& resp) {
Jason M. Billse1f26342018-07-18 12:12:00 -07002986 if (ec)
2987 {
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002988 BMCWEB_LOG_DEBUG << "failed to process PECI commands ec: "
Jason M. Billse1f26342018-07-18 12:12:00 -07002989 << ec.message();
Jason M. Billsf12894f2018-10-09 12:45:45 -07002990 messages::internalError(asyncResp->res);
Jason M. Billse1f26342018-07-18 12:12:00 -07002991 return;
2992 }
2993 asyncResp->res.jsonValue = {{"Name", "PECI Command Response"},
2994 {"PECIResponse", resp}};
2995 };
Ed Tanous1da66f72018-07-27 16:13:37 -07002996 // Call the SendRawPECI command with the provided data
2997 crow::connections::systemBus->async_method_call(
Jason M. Bills5b61b5e2019-10-16 10:59:02 -07002998 std::move(sendRawPECICallback), crashdumpObject, crashdumpPath,
Karthick Sundarrajan8724c292020-01-06 09:04:48 -08002999 crashdumpRawPECIInterface, "SendRawPeci", peciCommands);
Ed Tanous1da66f72018-07-27 16:13:37 -07003000 }
3001};
3002
Andrew Geisslercb92c032018-08-17 07:56:14 -07003003/**
3004 * DBusLogServiceActionsClear class supports POST method for ClearLog action.
3005 */
3006class DBusLogServiceActionsClear : public Node
3007{
3008 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07003009 DBusLogServiceActionsClear(App& app) :
Andrew Geisslercb92c032018-08-17 07:56:14 -07003010 Node(app, "/redfish/v1/Systems/system/LogServices/EventLog/Actions/"
Gunnar Mills7af91512020-04-14 22:16:57 -05003011 "LogService.ClearLog/")
Andrew Geisslercb92c032018-08-17 07:56:14 -07003012 {
3013 entityPrivileges = {
3014 {boost::beast::http::verb::get, {{"Login"}}},
3015 {boost::beast::http::verb::head, {{"Login"}}},
3016 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
3017 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
3018 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
3019 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
3020 }
3021
3022 private:
3023 /**
3024 * Function handles POST method request.
3025 * The Clear Log actions does not require any parameter.The action deletes
3026 * all entries found in the Entries collection for this Log Service.
3027 */
Ed Tanouscb13a392020-07-25 19:02:03 +00003028 void doPost(crow::Response& res, const crow::Request&,
3029 const std::vector<std::string>&) override
Andrew Geisslercb92c032018-08-17 07:56:14 -07003030 {
3031 BMCWEB_LOG_DEBUG << "Do delete all entries.";
3032
3033 auto asyncResp = std::make_shared<AsyncResp>(res);
3034 // Process response from Logging service.
3035 auto resp_handler = [asyncResp](const boost::system::error_code ec) {
3036 BMCWEB_LOG_DEBUG << "doClearLog resp_handler callback: Done";
3037 if (ec)
3038 {
3039 // TODO Handle for specific error code
3040 BMCWEB_LOG_ERROR << "doClearLog resp_handler got error " << ec;
3041 asyncResp->res.result(
3042 boost::beast::http::status::internal_server_error);
3043 return;
3044 }
3045
3046 asyncResp->res.result(boost::beast::http::status::no_content);
3047 };
3048
3049 // Make call to Logging service to request Clear Log
3050 crow::connections::systemBus->async_method_call(
3051 resp_handler, "xyz.openbmc_project.Logging",
3052 "/xyz/openbmc_project/logging",
3053 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3054 }
3055};
ZhikuiRena3316fc2020-01-29 14:58:08 -08003056
3057/****************************************************
3058 * Redfish PostCode interfaces
3059 * using DBUS interface: getPostCodesTS
3060 ******************************************************/
3061class PostCodesLogService : public Node
3062{
3063 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07003064 PostCodesLogService(App& app) :
ZhikuiRena3316fc2020-01-29 14:58:08 -08003065 Node(app, "/redfish/v1/Systems/system/LogServices/PostCodes/")
3066 {
3067 entityPrivileges = {
3068 {boost::beast::http::verb::get, {{"Login"}}},
3069 {boost::beast::http::verb::head, {{"Login"}}},
3070 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
3071 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
3072 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
3073 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
3074 }
3075
3076 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00003077 void doGet(crow::Response& res, const crow::Request&,
3078 const std::vector<std::string>&) override
ZhikuiRena3316fc2020-01-29 14:58:08 -08003079 {
3080 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
3081
3082 asyncResp->res.jsonValue = {
3083 {"@odata.id", "/redfish/v1/Systems/system/LogServices/PostCodes"},
3084 {"@odata.type", "#LogService.v1_1_0.LogService"},
3085 {"@odata.context", "/redfish/v1/$metadata#LogService.LogService"},
3086 {"Name", "POST Code Log Service"},
3087 {"Description", "POST Code Log Service"},
3088 {"Id", "BIOS POST Code Log"},
3089 {"OverWritePolicy", "WrapsWhenFull"},
3090 {"Entries",
3091 {{"@odata.id",
3092 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries"}}}};
3093 asyncResp->res.jsonValue["Actions"]["#LogService.ClearLog"] = {
3094 {"target", "/redfish/v1/Systems/system/LogServices/PostCodes/"
3095 "Actions/LogService.ClearLog"}};
3096 }
3097};
3098
3099class PostCodesClear : public Node
3100{
3101 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07003102 PostCodesClear(App& app) :
ZhikuiRena3316fc2020-01-29 14:58:08 -08003103 Node(app, "/redfish/v1/Systems/system/LogServices/PostCodes/Actions/"
3104 "LogService.ClearLog/")
3105 {
3106 entityPrivileges = {
3107 {boost::beast::http::verb::get, {{"Login"}}},
3108 {boost::beast::http::verb::head, {{"Login"}}},
AppaRao Puli39460282020-04-07 17:03:04 +05303109 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
3110 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
3111 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
3112 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
ZhikuiRena3316fc2020-01-29 14:58:08 -08003113 }
3114
3115 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00003116 void doPost(crow::Response& res, const crow::Request&,
3117 const std::vector<std::string>&) override
ZhikuiRena3316fc2020-01-29 14:58:08 -08003118 {
3119 BMCWEB_LOG_DEBUG << "Do delete all postcodes entries.";
3120
3121 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
3122 // Make call to post-code service to request clear all
3123 crow::connections::systemBus->async_method_call(
3124 [asyncResp](const boost::system::error_code ec) {
3125 if (ec)
3126 {
3127 // TODO Handle for specific error code
3128 BMCWEB_LOG_ERROR
3129 << "doClearPostCodes resp_handler got error " << ec;
3130 asyncResp->res.result(
3131 boost::beast::http::status::internal_server_error);
3132 messages::internalError(asyncResp->res);
3133 return;
3134 }
3135 },
3136 "xyz.openbmc_project.State.Boot.PostCode",
3137 "/xyz/openbmc_project/State/Boot/PostCode",
3138 "xyz.openbmc_project.Collection.DeleteAll", "DeleteAll");
3139 }
3140};
3141
3142static void fillPostCodeEntry(
3143 std::shared_ptr<AsyncResp> aResp,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003144 const boost::container::flat_map<uint64_t, uint64_t>& postcode,
ZhikuiRena3316fc2020-01-29 14:58:08 -08003145 const uint16_t bootIndex, const uint64_t codeIndex = 0,
3146 const uint64_t skip = 0, const uint64_t top = 0)
3147{
3148 // Get the Message from the MessageRegistry
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003149 const message_registries::Message* message =
ZhikuiRena3316fc2020-01-29 14:58:08 -08003150 message_registries::getMessage("OpenBMC.0.1.BIOSPOSTCode");
ZhikuiRena3316fc2020-01-29 14:58:08 -08003151
3152 uint64_t currentCodeIndex = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003153 nlohmann::json& logEntryArray = aResp->res.jsonValue["Members"];
ZhikuiRena3316fc2020-01-29 14:58:08 -08003154
3155 uint64_t firstCodeTimeUs = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003156 for (const std::pair<uint64_t, uint64_t>& code : postcode)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003157 {
3158 currentCodeIndex++;
3159 std::string postcodeEntryID =
3160 "B" + std::to_string(bootIndex) + "-" +
3161 std::to_string(currentCodeIndex); // 1 based index in EntryID string
3162
3163 uint64_t usecSinceEpoch = code.first;
3164 uint64_t usTimeOffset = 0;
3165
3166 if (1 == currentCodeIndex)
3167 { // already incremented
3168 firstCodeTimeUs = code.first;
3169 }
3170 else
3171 {
3172 usTimeOffset = code.first - firstCodeTimeUs;
3173 }
3174
3175 // skip if no specific codeIndex is specified and currentCodeIndex does
3176 // not fall between top and skip
3177 if ((codeIndex == 0) &&
3178 (currentCodeIndex <= skip || currentCodeIndex > top))
3179 {
3180 continue;
3181 }
3182
Gunnar Mills4e0453b2020-07-08 14:00:30 -05003183 // skip if a specific codeIndex is specified and does not match the
ZhikuiRena3316fc2020-01-29 14:58:08 -08003184 // currentIndex
3185 if ((codeIndex > 0) && (currentCodeIndex != codeIndex))
3186 {
3187 // This is done for simplicity. 1st entry is needed to calculate
3188 // time offset. To improve efficiency, one can get to the entry
3189 // directly (possibly with flatmap's nth method)
3190 continue;
3191 }
3192
3193 // currentCodeIndex is within top and skip or equal to specified code
3194 // index
3195
3196 // Get the Created time from the timestamp
3197 std::string entryTimeStr;
Asmitha Karunanithi9c620e22020-08-02 11:55:21 -05003198 entryTimeStr = crow::utility::getDateTime(
3199 static_cast<std::time_t>(usecSinceEpoch / 1000 / 1000));
ZhikuiRena3316fc2020-01-29 14:58:08 -08003200
3201 // assemble messageArgs: BootIndex, TimeOffset(100us), PostCode(hex)
3202 std::ostringstream hexCode;
3203 hexCode << "0x" << std::setfill('0') << std::setw(2) << std::hex
3204 << code.second;
3205 std::ostringstream timeOffsetStr;
3206 // Set Fixed -Point Notation
3207 timeOffsetStr << std::fixed;
3208 // Set precision to 4 digits
3209 timeOffsetStr << std::setprecision(4);
3210 // Add double to stream
3211 timeOffsetStr << static_cast<double>(usTimeOffset) / 1000 / 1000;
3212 std::vector<std::string> messageArgs = {
3213 std::to_string(bootIndex), timeOffsetStr.str(), hexCode.str()};
3214
3215 // Get MessageArgs template from message registry
3216 std::string msg;
3217 if (message != nullptr)
3218 {
3219 msg = message->message;
3220
3221 // fill in this post code value
3222 int i = 0;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003223 for (const std::string& messageArg : messageArgs)
ZhikuiRena3316fc2020-01-29 14:58:08 -08003224 {
3225 std::string argStr = "%" + std::to_string(++i);
3226 size_t argPos = msg.find(argStr);
3227 if (argPos != std::string::npos)
3228 {
3229 msg.replace(argPos, argStr.length(), messageArg);
3230 }
3231 }
3232 }
3233
Tim Leed4342a92020-04-27 11:47:58 +08003234 // Get Severity template from message registry
3235 std::string severity;
3236 if (message != nullptr)
3237 {
3238 severity = message->severity;
3239 }
3240
ZhikuiRena3316fc2020-01-29 14:58:08 -08003241 // add to AsyncResp
3242 logEntryArray.push_back({});
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003243 nlohmann::json& bmcLogEntry = logEntryArray.back();
ZhikuiRena3316fc2020-01-29 14:58:08 -08003244 bmcLogEntry = {
3245 {"@odata.type", "#LogEntry.v1_4_0.LogEntry"},
3246 {"@odata.context", "/redfish/v1/$metadata#LogEntry.LogEntry"},
3247 {"@odata.id", "/redfish/v1/Systems/system/LogServices/"
3248 "PostCodes/Entries/" +
3249 postcodeEntryID},
3250 {"Name", "POST Code Log Entry"},
3251 {"Id", postcodeEntryID},
3252 {"Message", std::move(msg)},
3253 {"MessageId", "OpenBMC.0.1.BIOSPOSTCode"},
3254 {"MessageArgs", std::move(messageArgs)},
3255 {"EntryType", "Event"},
3256 {"Severity", std::move(severity)},
Asmitha Karunanithi9c620e22020-08-02 11:55:21 -05003257 {"Created", entryTimeStr}};
ZhikuiRena3316fc2020-01-29 14:58:08 -08003258 }
3259}
3260
3261static void getPostCodeForEntry(std::shared_ptr<AsyncResp> aResp,
3262 const uint16_t bootIndex,
3263 const uint64_t codeIndex)
3264{
3265 crow::connections::systemBus->async_method_call(
3266 [aResp, bootIndex, codeIndex](
3267 const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003268 const boost::container::flat_map<uint64_t, uint64_t>& postcode) {
ZhikuiRena3316fc2020-01-29 14:58:08 -08003269 if (ec)
3270 {
3271 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
3272 messages::internalError(aResp->res);
3273 return;
3274 }
3275
3276 // skip the empty postcode boots
3277 if (postcode.empty())
3278 {
3279 return;
3280 }
3281
3282 fillPostCodeEntry(aResp, postcode, bootIndex, codeIndex);
3283
3284 aResp->res.jsonValue["Members@odata.count"] =
3285 aResp->res.jsonValue["Members"].size();
3286 },
3287 "xyz.openbmc_project.State.Boot.PostCode",
3288 "/xyz/openbmc_project/State/Boot/PostCode",
3289 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3290 bootIndex);
3291}
3292
3293static void getPostCodeForBoot(std::shared_ptr<AsyncResp> aResp,
3294 const uint16_t bootIndex,
3295 const uint16_t bootCount,
3296 const uint64_t entryCount, const uint64_t skip,
3297 const uint64_t top)
3298{
3299 crow::connections::systemBus->async_method_call(
3300 [aResp, bootIndex, bootCount, entryCount, skip,
3301 top](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003302 const boost::container::flat_map<uint64_t, uint64_t>& postcode) {
ZhikuiRena3316fc2020-01-29 14:58:08 -08003303 if (ec)
3304 {
3305 BMCWEB_LOG_DEBUG << "DBUS POST CODE PostCode response error";
3306 messages::internalError(aResp->res);
3307 return;
3308 }
3309
3310 uint64_t endCount = entryCount;
3311 if (!postcode.empty())
3312 {
3313 endCount = entryCount + postcode.size();
3314
3315 if ((skip < endCount) && ((top + skip) > entryCount))
3316 {
3317 uint64_t thisBootSkip =
3318 std::max(skip, entryCount) - entryCount;
3319 uint64_t thisBootTop =
3320 std::min(top + skip, endCount) - entryCount;
3321
3322 fillPostCodeEntry(aResp, postcode, bootIndex, 0,
3323 thisBootSkip, thisBootTop);
3324 }
3325 aResp->res.jsonValue["Members@odata.count"] = endCount;
3326 }
3327
3328 // continue to previous bootIndex
3329 if (bootIndex < bootCount)
3330 {
3331 getPostCodeForBoot(aResp, static_cast<uint16_t>(bootIndex + 1),
3332 bootCount, endCount, skip, top);
3333 }
3334 else
3335 {
3336 aResp->res.jsonValue["Members@odata.nextLink"] =
3337 "/redfish/v1/Systems/system/LogServices/PostCodes/"
3338 "Entries?$skip=" +
3339 std::to_string(skip + top);
3340 }
3341 },
3342 "xyz.openbmc_project.State.Boot.PostCode",
3343 "/xyz/openbmc_project/State/Boot/PostCode",
3344 "xyz.openbmc_project.State.Boot.PostCode", "GetPostCodesWithTimeStamp",
3345 bootIndex);
3346}
3347
3348static void getCurrentBootNumber(std::shared_ptr<AsyncResp> aResp,
3349 const uint64_t skip, const uint64_t top)
3350{
3351 uint64_t entryCount = 0;
3352 crow::connections::systemBus->async_method_call(
3353 [aResp, entryCount, skip,
3354 top](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003355 const std::variant<uint16_t>& bootCount) {
ZhikuiRena3316fc2020-01-29 14:58:08 -08003356 if (ec)
3357 {
3358 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
3359 messages::internalError(aResp->res);
3360 return;
3361 }
3362 auto pVal = std::get_if<uint16_t>(&bootCount);
3363 if (pVal)
3364 {
3365 getPostCodeForBoot(aResp, 1, *pVal, entryCount, skip, top);
3366 }
3367 else
3368 {
3369 BMCWEB_LOG_DEBUG << "Post code boot index failed.";
3370 }
3371 },
3372 "xyz.openbmc_project.State.Boot.PostCode",
3373 "/xyz/openbmc_project/State/Boot/PostCode",
3374 "org.freedesktop.DBus.Properties", "Get",
3375 "xyz.openbmc_project.State.Boot.PostCode", "CurrentBootCycleCount");
3376}
3377
3378class PostCodesEntryCollection : public Node
3379{
3380 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07003381 PostCodesEntryCollection(App& app) :
ZhikuiRena3316fc2020-01-29 14:58:08 -08003382 Node(app, "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/")
3383 {
3384 entityPrivileges = {
3385 {boost::beast::http::verb::get, {{"Login"}}},
3386 {boost::beast::http::verb::head, {{"Login"}}},
3387 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
3388 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
3389 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
3390 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
3391 }
3392
3393 private:
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003394 void doGet(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00003395 const std::vector<std::string>&) override
ZhikuiRena3316fc2020-01-29 14:58:08 -08003396 {
3397 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
3398
3399 asyncResp->res.jsonValue["@odata.type"] =
3400 "#LogEntryCollection.LogEntryCollection";
3401 asyncResp->res.jsonValue["@odata.context"] =
3402 "/redfish/v1/"
3403 "$metadata#LogEntryCollection.LogEntryCollection";
3404 asyncResp->res.jsonValue["@odata.id"] =
3405 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries";
3406 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
3407 asyncResp->res.jsonValue["Description"] =
3408 "Collection of POST Code Log Entries";
3409 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3410 asyncResp->res.jsonValue["Members@odata.count"] = 0;
3411
3412 uint64_t skip = 0;
3413 uint64_t top = maxEntriesPerPage; // Show max entries by default
3414 if (!getSkipParam(asyncResp->res, req, skip))
3415 {
3416 return;
3417 }
3418 if (!getTopParam(asyncResp->res, req, top))
3419 {
3420 return;
3421 }
3422 getCurrentBootNumber(asyncResp, skip, top);
3423 }
3424};
3425
3426class PostCodesEntry : public Node
3427{
3428 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07003429 PostCodesEntry(App& app) :
ZhikuiRena3316fc2020-01-29 14:58:08 -08003430 Node(app,
3431 "/redfish/v1/Systems/system/LogServices/PostCodes/Entries/<str>/",
3432 std::string())
3433 {
3434 entityPrivileges = {
3435 {boost::beast::http::verb::get, {{"Login"}}},
3436 {boost::beast::http::verb::head, {{"Login"}}},
3437 {boost::beast::http::verb::patch, {{"ConfigureManager"}}},
3438 {boost::beast::http::verb::put, {{"ConfigureManager"}}},
3439 {boost::beast::http::verb::delete_, {{"ConfigureManager"}}},
3440 {boost::beast::http::verb::post, {{"ConfigureManager"}}}};
3441 }
3442
3443 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00003444 void doGet(crow::Response& res, const crow::Request&,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003445 const std::vector<std::string>& params) override
ZhikuiRena3316fc2020-01-29 14:58:08 -08003446 {
3447 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
3448 if (params.size() != 1)
3449 {
3450 messages::internalError(asyncResp->res);
3451 return;
3452 }
3453
Gunnar Mills1214b7e2020-06-04 10:11:30 -05003454 const std::string& targetID = params[0];
ZhikuiRena3316fc2020-01-29 14:58:08 -08003455
3456 size_t bootPos = targetID.find('B');
3457 if (bootPos == std::string::npos)
3458 {
3459 // Requested ID was not found
3460 messages::resourceMissingAtURI(asyncResp->res, targetID);
3461 return;
3462 }
3463 std::string_view bootIndexStr(targetID);
3464 bootIndexStr.remove_prefix(bootPos + 1);
3465 uint16_t bootIndex = 0;
3466 uint64_t codeIndex = 0;
3467 size_t dashPos = bootIndexStr.find('-');
3468
3469 if (dashPos == std::string::npos)
3470 {
3471 return;
3472 }
3473 std::string_view codeIndexStr(bootIndexStr);
3474 bootIndexStr.remove_suffix(dashPos);
3475 codeIndexStr.remove_prefix(dashPos + 1);
3476
3477 bootIndex = static_cast<uint16_t>(
Ed Tanous23a21a12020-07-25 04:45:05 +00003478 strtoul(std::string(bootIndexStr).c_str(), nullptr, 0));
3479 codeIndex = strtoul(std::string(codeIndexStr).c_str(), nullptr, 0);
ZhikuiRena3316fc2020-01-29 14:58:08 -08003480 if (bootIndex == 0 || codeIndex == 0)
3481 {
3482 BMCWEB_LOG_DEBUG << "Get Post Code invalid entry string "
3483 << params[0];
3484 }
3485
3486 asyncResp->res.jsonValue["@odata.type"] = "#LogEntry.v1_4_0.LogEntry";
3487 asyncResp->res.jsonValue["@odata.context"] =
3488 "/redfish/v1/$metadata#LogEntry.LogEntry";
3489 asyncResp->res.jsonValue["@odata.id"] =
3490 "/redfish/v1/Systems/system/LogServices/PostCodes/"
3491 "Entries";
3492 asyncResp->res.jsonValue["Name"] = "BIOS POST Code Log Entries";
3493 asyncResp->res.jsonValue["Description"] =
3494 "Collection of POST Code Log Entries";
3495 asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
3496 asyncResp->res.jsonValue["Members@odata.count"] = 0;
3497
3498 getPostCodeForEntry(asyncResp, bootIndex, codeIndex);
3499 }
3500};
3501
Ed Tanous1da66f72018-07-27 16:13:37 -07003502} // namespace redfish