dump_manager_bmc.cpp - openbmc/phosphor-debug-collector - Gitiles

 #include "config.h"

 #include "dump_manager_bmc.hpp"

 #include "bmc_dump_entry.hpp"
 #include "dump_internal.hpp"
 #include "dump_types.hpp"
 #include "xyz/openbmc_project/Common/error.hpp"
 #include "xyz/openbmc_project/Dump/Create/error.hpp"

 #include <sys/inotify.h>
 #include <unistd.h>

 #include <phosphor-logging/elog-errors.hpp>
 #include <phosphor-logging/elog.hpp>
 #include <phosphor-logging/lg2.hpp>
 #include <sdeventplus/exception.hpp>
 #include <sdeventplus/source/base.hpp>

 #include <cmath>
 #include <ctime>
 #include <regex>

 namespace phosphor
 {
 namespace dump
 {
 namespace bmc
 {

 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 using namespace phosphor::logging;

 bool Manager::fUserDumpInProgress = false;
 constexpr auto BMC_DUMP = "BMC_DUMP";

 namespace internal
 {

 void Manager::create(Type type, std::vector<std::string> fullPaths)
 {
     dumpMgr.phosphor::dump::bmc::Manager::captureDump(type, fullPaths);
 }

 } // namespace internal

 sdbusplus::message::object_path
     Manager::createDump(phosphor::dump::DumpCreateParams params)
 {
     if (params.size() > CREATE_DUMP_MAX_PARAMS)
     {
         lg2::warning("BMC dump accepts not more than 2 additional parameters");
     }

     // Get the originator id and type from params
     std::string originatorId;
     originatorTypes originatorType;

     phosphor::dump::extractOriginatorProperties(params, originatorId,
                                                 originatorType);

     using CreateParameters =
         sdbusplus::common::xyz::openbmc_project::dump::Create::CreateParameters;

     DumpTypes dumpType = DumpTypes::USER;
     std::string type = extractParameter<std::string>(
         convertCreateParametersToString(CreateParameters::DumpType), params);
     if (!type.empty())
     {
         dumpType = validateDumpType(type, BMC_DUMP);
     }
     std::string path = extractParameter<std::string>(
         convertCreateParametersToString(CreateParameters::FilePath), params);

     if ((Manager::fUserDumpInProgress == true) && (dumpType == DumpTypes::USER))
     {
         lg2::info("Another user initiated dump in progress");
         elog<sdbusplus::xyz::openbmc_project::Common::Error::Unavailable>();
     }

     lg2::info("Initiating new BMC dump with type: {TYPE} path: {PATH}", "TYPE",
               dumpTypeToString(dumpType).value(), "PATH", path);

     auto id = captureDump(dumpType, path);

     // Entry Object path.
     auto objPath = std::filesystem::path(baseEntryPath) / std::to_string(id);

     try
     {
         uint64_t timeStamp =
             std::chrono::duration_cast<std::chrono::microseconds>(
                 std::chrono::system_clock::now().time_since_epoch())
                 .count();

         entries.insert(std::make_pair(
             id, std::make_unique<bmc::Entry>(
                     bus, objPath.c_str(), id, timeStamp, 0, std::string(),
                     phosphor::dump::OperationStatus::InProgress, originatorId,
                     originatorType, *this)));
     }
     catch (const std::invalid_argument& e)
     {
         lg2::error("Error in creating dump entry, errormsg: {ERROR}, "
                    "OBJECTPATH: {OBJECT_PATH}, ID: {ID}",
                    "ERROR", e, "OBJECT_PATH", objPath, "ID", id);
         elog<InternalFailure>();
     }

     if (dumpType == DumpTypes::USER)
     {
         Manager::fUserDumpInProgress = true;
     }
     return objPath.string();
 }

 uint32_t Manager::captureDump(Type type,
                               const std::vector<std::string>& fullPaths)
 {
     // get dreport type map entry
     auto tempType = TypeMap.find(type);
     return captureDump(stringToDumpType(tempType->second).value(),
                        fullPaths.front());
 }
 uint32_t Manager::captureDump(DumpTypes type, const std::string& path)
 {
     // Get Dump size.
     auto size = getAllowedSize();

     pid_t pid = fork();

     if (pid == 0)
     {
         std::filesystem::path dumpPath(dumpDir);
         auto id = std::to_string(lastEntryId + 1);
         dumpPath /= id;

         auto strType = dumpTypeToString(type).value();
         execl("/usr/bin/dreport", "dreport", "-d", dumpPath.c_str(), "-i",
               id.c_str(), "-s", std::to_string(size).c_str(), "-q", "-v", "-p",
               path.empty() ? "" : path.c_str(), "-t", strType.c_str(), nullptr);

         // dreport script execution is failed.
         auto error = errno;
         lg2::error("Error occurred during dreport function execution, "
                    "errno: {ERRNO}",
                    "ERRNO", error);
         elog<InternalFailure>();
     }
     else if (pid > 0)
     {
         Child::Callback callback = [this, type, pid](Child&, const siginfo_t*) {
             if (type == DumpTypes::USER)
             {
                 lg2::info("User initiated dump completed, resetting flag");
                 Manager::fUserDumpInProgress = false;
             }
             this->childPtrMap.erase(pid);
         };
         try
         {
             childPtrMap.emplace(pid,
                                 std::make_unique<Child>(eventLoop.get(), pid,
                                                         WEXITED | WSTOPPED,
                                                         std::move(callback)));
         }
         catch (const sdeventplus::SdEventError& ex)
         {
             // Failed to add to event loop
             lg2::error(
                 "Error occurred during the sdeventplus::source::Child creation "
                 "ex: {ERROR}",
                 "ERROR", ex);
             elog<InternalFailure>();
         }
     }
     else
     {
         auto error = errno;
         lg2::error("Error occurred during fork, errno: {ERRNO}", "ERRNO",
                    error);
         elog<InternalFailure>();
     }
     return ++lastEntryId;
 }

 void Manager::createEntry(const std::filesystem::path& file)
 {
     // Dump File Name format obmcdump_ID_EPOCHTIME.EXT
     static constexpr auto ID_POS = 1;
     static constexpr auto EPOCHTIME_POS = 2;
     std::regex file_regex("obmcdump_([0-9]+)_([0-9]+).([a-zA-Z0-9]+)");

     std::smatch match;
     std::string name = file.filename();

     if (!((std::regex_search(name, match, file_regex)) && (match.size() > 0)))
     {
         lg2::error("Invalid Dump file name, FILENAME: {FILENAME}", "FILENAME",
                    file);
         return;
     }

     auto idString = match[ID_POS];
     uint64_t timestamp = stoull(match[EPOCHTIME_POS]) * 1000 * 1000;

     auto id = stoul(idString);

     // If there is an existing entry update it and return.
     auto dumpEntry = entries.find(id);
     if (dumpEntry != entries.end())
     {
         dynamic_cast<phosphor::dump::bmc::Entry*>(dumpEntry->second.get())
             ->update(timestamp, std::filesystem::file_size(file), file);
         return;
     }

     // Entry Object path.
     auto objPath = std::filesystem::path(baseEntryPath) / std::to_string(id);

     // TODO: Get the persisted originator id & type
     // For now, replacing it with null
     try
     {
         entries.insert(std::make_pair(
             id, std::make_unique<bmc::Entry>(
                     bus, objPath.c_str(), id, timestamp,
                     std::filesystem::file_size(file), file,
                     phosphor::dump::OperationStatus::Completed, std::string(),
                     originatorTypes::Internal, *this)));
     }
     catch (const std::invalid_argument& e)
     {
         lg2::error(
             "Error in creating dump entry, errormsg: {ERROR}, "
             "OBJECTPATH: {OBJECT_PATH}, ID: {ID}, TIMESTAMP: {TIMESTAMP}, "
             "SIZE: {SIZE}, FILENAME: {FILENAME}",
             "ERROR", e, "OBJECT_PATH", objPath, "ID", id, "TIMESTAMP",
             timestamp, "SIZE", std::filesystem::file_size(file), "FILENAME",
             file);
         return;
     }
 }

 void Manager::watchCallback(const UserMap& fileInfo)
 {
     for (const auto& i : fileInfo)
     {
         // For any new dump file create dump entry object
         // and associated inotify watch.
         if (IN_CLOSE_WRITE == i.second)
         {
             if (!std::filesystem::is_directory(i.first))
             {
                 // Don't require filename to be passed, as the path
                 // of dump directory is stored in the childWatchMap
                 removeWatch(i.first.parent_path());

                 // dump file is written now create D-Bus entry
                 createEntry(i.first);
             }
             else
             {
                 removeWatch(i.first);
             }
         }
         // Start inotify watch on newly created directory.
         else if ((IN_CREATE == i.second) &&
                  std::filesystem::is_directory(i.first))
         {
             auto watchObj = std::make_unique<Watch>(
                 eventLoop, IN_NONBLOCK, IN_CLOSE_WRITE, EPOLLIN, i.first,
                 std::bind(
                     std::mem_fn(&phosphor::dump::bmc::Manager::watchCallback),
                     this, std::placeholders::_1));

             childWatchMap.emplace(i.first, std::move(watchObj));
         }
     }
 }

 void Manager::removeWatch(const std::filesystem::path& path)
 {
     // Delete Watch entry from map.
     childWatchMap.erase(path);
 }

 void Manager::restore()
 {
     std::filesystem::path dir(dumpDir);
     if (!std::filesystem::exists(dir) || std::filesystem::is_empty(dir))
     {
         return;
     }

     // Dump file path: <DUMP_PATH>/<id>/<filename>
     for (const auto& p : std::filesystem::directory_iterator(dir))
     {
         auto idStr = p.path().filename().string();

         // Consider only directory's with dump id as name.
         // Note: As per design one file per directory.
         if ((std::filesystem::is_directory(p.path())) &&
             std::all_of(idStr.begin(), idStr.end(), ::isdigit))
         {
             lastEntryId = std::max(lastEntryId,
                                    static_cast<uint32_t>(std::stoul(idStr)));
             auto fileIt = std::filesystem::directory_iterator(p.path());
             // Create dump entry d-bus object.
             if (fileIt != std::filesystem::end(fileIt))
             {
                 createEntry(fileIt->path());
             }
         }
     }
 }

 size_t getDirectorySize(const std::string dir)
 {
     auto size = 0;
     for (const auto& p : std::filesystem::recursive_directory_iterator(dir))
     {
         if (!std::filesystem::is_directory(p))
         {
             size += std::ceil(std::filesystem::file_size(p) / 1024.0);
         }
     }
     return size;
 }

 size_t Manager::getAllowedSize()
 {
     // Get current size of the dump directory.
     auto size = getDirectorySize(dumpDir);

     // Set the Dump size to Maximum  if the free space is greater than
     // Dump max size otherwise return the available size.

     size = (size > BMC_DUMP_TOTAL_SIZE ? 0 : BMC_DUMP_TOTAL_SIZE - size);

 #ifdef BMC_DUMP_ROTATE_CONFIG
     // Delete the first existing file until the space is enough
     while (size < BMC_DUMP_MIN_SPACE_REQD)
     {
         auto delEntry = min_element(entries.begin(), entries.end(),
                                     [](const auto& l, const auto& r) {
             return l.first < r.first;
         });
         auto delPath = std::filesystem::path(dumpDir) /
                        std::to_string(delEntry->first);

         size += getDirectorySize(delPath);

         delEntry->second->delete_();
     }
 #else
     using namespace sdbusplus::xyz::openbmc_project::Dump::Create::Error;
     using Reason = xyz::openbmc_project::Dump::Create::QuotaExceeded::REASON;

     if (size < BMC_DUMP_MIN_SPACE_REQD)
     {
         // Reached to maximum limit
         elog<QuotaExceeded>(Reason("Not enough space: Delete old dumps"));
     }
 #endif

     if (size > BMC_DUMP_MAX_SIZE)
     {
         size = BMC_DUMP_MAX_SIZE;
     }

     return size;
 }

 } // namespace bmc
 } // namespace dump
 } // namespace phosphor
	#include "config.h"

	#include "dump_manager_bmc.hpp"

	#include "bmc_dump_entry.hpp"
	#include "dump_internal.hpp"
	#include "dump_types.hpp"
	#include "xyz/openbmc_project/Common/error.hpp"
	#include "xyz/openbmc_project/Dump/Create/error.hpp"

	#include <sys/inotify.h>
	#include <unistd.h>

	#include <phosphor-logging/elog-errors.hpp>
	#include <phosphor-logging/elog.hpp>
	#include <phosphor-logging/lg2.hpp>
	#include <sdeventplus/exception.hpp>
	#include <sdeventplus/source/base.hpp>

	#include <cmath>
	#include <ctime>
	#include <regex>

	namespace phosphor
	{
	namespace dump
	{
	namespace bmc
	{

	using namespace sdbusplus::xyz::openbmc_project::Common::Error;
	using namespace phosphor::logging;

	bool Manager::fUserDumpInProgress = false;
	constexpr auto BMC_DUMP = "BMC_DUMP";

	namespace internal
	{

	void Manager::create(Type type, std::vector<std::string> fullPaths)
	{
	dumpMgr.phosphor::dump::bmc::Manager::captureDump(type, fullPaths);
	}

	} // namespace internal

	sdbusplus::message::object_path
	Manager::createDump(phosphor::dump::DumpCreateParams params)
	{
	if (params.size() > CREATE_DUMP_MAX_PARAMS)
	{
	lg2::warning("BMC dump accepts not more than 2 additional parameters");
	}

	// Get the originator id and type from params
	std::string originatorId;
	originatorTypes originatorType;

	phosphor::dump::extractOriginatorProperties(params, originatorId,
	originatorType);

	using CreateParameters =
	sdbusplus::common::xyz::openbmc_project::dump::Create::CreateParameters;

	DumpTypes dumpType = DumpTypes::USER;
	std::string type = extractParameter<std::string>(
	convertCreateParametersToString(CreateParameters::DumpType), params);
	if (!type.empty())
	{
	dumpType = validateDumpType(type, BMC_DUMP);
	}
	std::string path = extractParameter<std::string>(
	convertCreateParametersToString(CreateParameters::FilePath), params);

	if ((Manager::fUserDumpInProgress == true) && (dumpType == DumpTypes::USER))
	{
	lg2::info("Another user initiated dump in progress");
	elog<sdbusplus::xyz::openbmc_project::Common::Error::Unavailable>();
	}

	lg2::info("Initiating new BMC dump with type: {TYPE} path: {PATH}", "TYPE",
	dumpTypeToString(dumpType).value(), "PATH", path);

	auto id = captureDump(dumpType, path);

	// Entry Object path.
	auto objPath = std::filesystem::path(baseEntryPath) / std::to_string(id);

	try
	{
	uint64_t timeStamp =
	std::chrono::duration_cast<std::chrono::microseconds>(
	std::chrono::system_clock::now().time_since_epoch())
	.count();

	entries.insert(std::make_pair(
	id, std::make_unique<bmc::Entry>(
	bus, objPath.c_str(), id, timeStamp, 0, std::string(),
	phosphor::dump::OperationStatus::InProgress, originatorId,
	originatorType, *this)));
	}
	catch (const std::invalid_argument& e)
	{
	lg2::error("Error in creating dump entry, errormsg: {ERROR}, "
	"OBJECTPATH: {OBJECT_PATH}, ID: {ID}",
	"ERROR", e, "OBJECT_PATH", objPath, "ID", id);
	elog<InternalFailure>();
	}

	if (dumpType == DumpTypes::USER)
	{
	Manager::fUserDumpInProgress = true;
	}
	return objPath.string();
	}

	uint32_t Manager::captureDump(Type type,
	const std::vector<std::string>& fullPaths)
	{
	// get dreport type map entry
	auto tempType = TypeMap.find(type);
	return captureDump(stringToDumpType(tempType->second).value(),
	fullPaths.front());
	}
	uint32_t Manager::captureDump(DumpTypes type, const std::string& path)
	{
	// Get Dump size.
	auto size = getAllowedSize();

	pid_t pid = fork();

	if (pid == 0)
	{
	std::filesystem::path dumpPath(dumpDir);
	auto id = std::to_string(lastEntryId + 1);
	dumpPath /= id;

	auto strType = dumpTypeToString(type).value();
	execl("/usr/bin/dreport", "dreport", "-d", dumpPath.c_str(), "-i",
	id.c_str(), "-s", std::to_string(size).c_str(), "-q", "-v", "-p",
	path.empty() ? "" : path.c_str(), "-t", strType.c_str(), nullptr);

	// dreport script execution is failed.
	auto error = errno;
	lg2::error("Error occurred during dreport function execution, "
	"errno: {ERRNO}",
	"ERRNO", error);
	elog<InternalFailure>();
	}
	else if (pid > 0)
	{
	Child::Callback callback = [this, type, pid](Child&, const siginfo_t*) {
	if (type == DumpTypes::USER)
	{
	lg2::info("User initiated dump completed, resetting flag");
	Manager::fUserDumpInProgress = false;
	}
	this->childPtrMap.erase(pid);
	};
	try
	{
	childPtrMap.emplace(pid,
	std::make_unique<Child>(eventLoop.get(), pid,
	WEXITED \| WSTOPPED,
	std::move(callback)));
	}
	catch (const sdeventplus::SdEventError& ex)
	{
	// Failed to add to event loop
	lg2::error(
	"Error occurred during the sdeventplus::source::Child creation "
	"ex: {ERROR}",
	"ERROR", ex);
	elog<InternalFailure>();
	}
	}
	else
	{
	auto error = errno;
	lg2::error("Error occurred during fork, errno: {ERRNO}", "ERRNO",
	error);
	elog<InternalFailure>();
	}
	return ++lastEntryId;
	}

	void Manager::createEntry(const std::filesystem::path& file)
	{
	// Dump File Name format obmcdump_ID_EPOCHTIME.EXT
	static constexpr auto ID_POS = 1;
	static constexpr auto EPOCHTIME_POS = 2;
	std::regex file_regex("obmcdump_([0-9]+)_([0-9]+).([a-zA-Z0-9]+)");

	std::smatch match;
	std::string name = file.filename();

	if (!((std::regex_search(name, match, file_regex)) && (match.size() > 0)))
	{
	lg2::error("Invalid Dump file name, FILENAME: {FILENAME}", "FILENAME",
	file);
	return;
	}

	auto idString = match[ID_POS];
	uint64_t timestamp = stoull(match[EPOCHTIME_POS]) * 1000 * 1000;

	auto id = stoul(idString);

	// If there is an existing entry update it and return.
	auto dumpEntry = entries.find(id);
	if (dumpEntry != entries.end())
	{
	dynamic_cast<phosphor::dump::bmc::Entry*>(dumpEntry->second.get())
	->update(timestamp, std::filesystem::file_size(file), file);
	return;
	}

	// Entry Object path.
	auto objPath = std::filesystem::path(baseEntryPath) / std::to_string(id);

	// TODO: Get the persisted originator id & type
	// For now, replacing it with null
	try
	{
	entries.insert(std::make_pair(
	id, std::make_unique<bmc::Entry>(
	bus, objPath.c_str(), id, timestamp,
	std::filesystem::file_size(file), file,
	phosphor::dump::OperationStatus::Completed, std::string(),
	originatorTypes::Internal, *this)));
	}
	catch (const std::invalid_argument& e)
	{
	lg2::error(
	"Error in creating dump entry, errormsg: {ERROR}, "
	"OBJECTPATH: {OBJECT_PATH}, ID: {ID}, TIMESTAMP: {TIMESTAMP}, "
	"SIZE: {SIZE}, FILENAME: {FILENAME}",
	"ERROR", e, "OBJECT_PATH", objPath, "ID", id, "TIMESTAMP",
	timestamp, "SIZE", std::filesystem::file_size(file), "FILENAME",
	file);
	return;
	}
	}

	void Manager::watchCallback(const UserMap& fileInfo)
	{
	for (const auto& i : fileInfo)
	{
	// For any new dump file create dump entry object
	// and associated inotify watch.
	if (IN_CLOSE_WRITE == i.second)
	{
	if (!std::filesystem::is_directory(i.first))
	{
	// Don't require filename to be passed, as the path
	// of dump directory is stored in the childWatchMap
	removeWatch(i.first.parent_path());

	// dump file is written now create D-Bus entry
	createEntry(i.first);
	}
	else
	{
	removeWatch(i.first);
	}
	}
	// Start inotify watch on newly created directory.
	else if ((IN_CREATE == i.second) &&
	std::filesystem::is_directory(i.first))
	{
	auto watchObj = std::make_unique<Watch>(
	eventLoop, IN_NONBLOCK, IN_CLOSE_WRITE, EPOLLIN, i.first,
	std::bind(
	std::mem_fn(&phosphor::dump::bmc::Manager::watchCallback),
	this, std::placeholders::_1));

	childWatchMap.emplace(i.first, std::move(watchObj));
	}
	}
	}

	void Manager::removeWatch(const std::filesystem::path& path)
	{
	// Delete Watch entry from map.
	childWatchMap.erase(path);
	}

	void Manager::restore()
	{
	std::filesystem::path dir(dumpDir);
	if (!std::filesystem::exists(dir) \|\| std::filesystem::is_empty(dir))
	{
	return;
	}

	// Dump file path: <DUMP_PATH>/<id>/<filename>
	for (const auto& p : std::filesystem::directory_iterator(dir))
	{
	auto idStr = p.path().filename().string();

	// Consider only directory's with dump id as name.
	// Note: As per design one file per directory.
	if ((std::filesystem::is_directory(p.path())) &&
	std::all_of(idStr.begin(), idStr.end(), ::isdigit))
	{
	lastEntryId = std::max(lastEntryId,
	static_cast<uint32_t>(std::stoul(idStr)));
	auto fileIt = std::filesystem::directory_iterator(p.path());
	// Create dump entry d-bus object.
	if (fileIt != std::filesystem::end(fileIt))
	{
	createEntry(fileIt->path());
	}
	}
	}
	}

	size_t getDirectorySize(const std::string dir)
	{
	auto size = 0;
	for (const auto& p : std::filesystem::recursive_directory_iterator(dir))
	{
	if (!std::filesystem::is_directory(p))
	{
	size += std::ceil(std::filesystem::file_size(p) / 1024.0);
	}
	}
	return size;
	}

	size_t Manager::getAllowedSize()
	{
	// Get current size of the dump directory.
	auto size = getDirectorySize(dumpDir);

	// Set the Dump size to Maximum if the free space is greater than
	// Dump max size otherwise return the available size.

	size = (size > BMC_DUMP_TOTAL_SIZE ? 0 : BMC_DUMP_TOTAL_SIZE - size);

	#ifdef BMC_DUMP_ROTATE_CONFIG
	// Delete the first existing file until the space is enough
	while (size < BMC_DUMP_MIN_SPACE_REQD)
	{
	auto delEntry = min_element(entries.begin(), entries.end(),
	[](const auto& l, const auto& r) {
	return l.first < r.first;
	});
	auto delPath = std::filesystem::path(dumpDir) /
	std::to_string(delEntry->first);

	size += getDirectorySize(delPath);

	delEntry->second->delete_();
	}
	#else
	using namespace sdbusplus::xyz::openbmc_project::Dump::Create::Error;
	using Reason = xyz::openbmc_project::Dump::Create::QuotaExceeded::REASON;

	if (size < BMC_DUMP_MIN_SPACE_REQD)
	{
	// Reached to maximum limit
	elog<QuotaExceeded>(Reason("Not enough space: Delete old dumps"));
	}
	#endif

	if (size > BMC_DUMP_MAX_SIZE)
	{
	size = BMC_DUMP_MAX_SIZE;
	}

	return size;
	}

	} // namespace bmc
	} // namespace dump
	} // namespace phosphor