blob: fea2ba931b988e491d1547f72026403c37d0fd53 [file] [log] [blame]
/**
* Copyright © 2019 IBM Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "manager.hpp"
#include "additional_data.hpp"
#include "json_utils.hpp"
#include "pel.hpp"
#include <unistd.h>
#include <filesystem>
#include <fstream>
#include <xyz/openbmc_project/Common/error.hpp>
#include <xyz/openbmc_project/Logging/Create/server.hpp>
namespace openpower
{
namespace pels
{
using namespace phosphor::logging;
namespace fs = std::filesystem;
namespace rg = openpower::pels::message;
namespace common_error = sdbusplus::xyz::openbmc_project::Common::Error;
using Create = sdbusplus::xyz::openbmc_project::Logging::server::Create;
namespace additional_data
{
constexpr auto rawPEL = "RAWPEL";
constexpr auto esel = "ESEL";
} // namespace additional_data
void Manager::create(const std::string& message, uint32_t obmcLogID,
uint64_t timestamp, Entry::Level severity,
const std::vector<std::string>& additionalData,
const std::vector<std::string>& associations,
const FFDCEntries& ffdc)
{
AdditionalData ad{additionalData};
// If a PEL was passed in via a filename or in an ESEL,
// use that. Otherwise, create one.
auto rawPelPath = ad.getValue(additional_data::rawPEL);
if (rawPelPath)
{
addRawPEL(*rawPelPath, obmcLogID);
}
else
{
auto esel = ad.getValue(additional_data::esel);
if (esel)
{
addESELPEL(*esel, obmcLogID);
}
else
{
createPEL(message, obmcLogID, timestamp, severity, additionalData,
associations, ffdc);
}
}
}
void Manager::addRawPEL(const std::string& rawPelPath, uint32_t obmcLogID)
{
if (fs::exists(rawPelPath))
{
std::ifstream file(rawPelPath, std::ios::in | std::ios::binary);
auto data = std::vector<uint8_t>(std::istreambuf_iterator<char>(file),
std::istreambuf_iterator<char>());
if (file.fail())
{
log<level::ERR>("Filesystem error reading a raw PEL",
entry("PELFILE=%s", rawPelPath.c_str()),
entry("OBMCLOGID=%d", obmcLogID));
// TODO, Decide what to do here. Maybe nothing.
return;
}
file.close();
addPEL(data, obmcLogID);
}
else
{
log<level::ERR>("Raw PEL file from BMC event log does not exist",
entry("PELFILE=%s", (rawPelPath).c_str()),
entry("OBMCLOGID=%d", obmcLogID));
}
}
void Manager::addPEL(std::vector<uint8_t>& pelData, uint32_t obmcLogID)
{
auto pel = std::make_unique<openpower::pels::PEL>(pelData, obmcLogID);
if (pel->valid())
{
// PELs created by others still need these fields set by us.
pel->assignID();
pel->setCommitTime();
try
{
log<level::DEBUG>("Adding external PEL to repo",
entry("PEL_ID=0x%X", pel->id()));
_repo.add(pel);
if (_repo.sizeWarning())
{
scheduleRepoPrune();
}
}
catch (std::exception& e)
{
// Probably a full or r/o filesystem, not much we can do.
log<level::ERR>("Unable to add PEL to Repository",
entry("PEL_ID=0x%X", pel->id()));
}
}
else
{
log<level::ERR>("Invalid PEL received from the host",
entry("OBMCLOGID=%d", obmcLogID));
AdditionalData ad;
ad.add("PLID", getNumberString("0x%08X", pel->plid()));
ad.add("OBMC_LOG_ID", std::to_string(obmcLogID));
ad.add("PEL_SIZE", std::to_string(pelData.size()));
std::string asciiString;
auto src = pel->primarySRC();
if (src)
{
asciiString = (*src)->asciiString();
}
ad.add("SRC", asciiString);
_eventLogger.log("org.open_power.Logging.Error.BadHostPEL",
Entry::Level::Error, ad);
// Save it to a file for debug in the lab. Just keep the latest.
// Not adding it to the PEL because it could already be max size
// and don't want to truncate an already invalid PEL.
std::ofstream pelFile{getPELRepoPath() / "badPEL"};
pelFile.write(reinterpret_cast<const char*>(pelData.data()),
pelData.size());
}
}
void Manager::addESELPEL(const std::string& esel, uint32_t obmcLogID)
{
std::vector<uint8_t> data;
log<level::DEBUG>("Adding PEL from ESEL",
entry("OBMC_LOG_ID=%d", obmcLogID));
try
{
data = std::move(eselToRawData(esel));
}
catch (std::exception& e)
{
// Try to add it below anyway, so it follows the usual bad data path.
log<level::ERR>("Problems converting ESEL string to a byte vector");
}
addPEL(data, obmcLogID);
}
std::vector<uint8_t> Manager::eselToRawData(const std::string& esel)
{
std::vector<uint8_t> data;
std::string byteString;
// As the eSEL string looks like: "50 48 00 ab ..." there are 3
// characters per raw byte, and since the actual PEL data starts
// at the 16th byte, the code will grab the PEL data starting at
// offset 48 in the string.
static constexpr size_t pelStart = 16 * 3;
if (esel.size() <= pelStart)
{
log<level::ERR>("ESEL data too short",
entry("ESEL_SIZE=%d", esel.size()));
throw std::length_error("ESEL data too short");
}
for (size_t i = pelStart; i < esel.size(); i += 3)
{
if (i + 1 < esel.size())
{
byteString = esel.substr(i, 2);
data.push_back(std::stoi(byteString, nullptr, 16));
}
else
{
log<level::ERR>("ESEL data too short",
entry("ESEL_SIZE=%d", esel.size()));
throw std::length_error("ESEL data too short");
}
}
return data;
}
void Manager::erase(uint32_t obmcLogID)
{
Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
_repo.remove(id);
}
bool Manager::isDeleteProhibited(uint32_t obmcLogID)
{
return false;
}
PelFFDC Manager::convertToPelFFDC(const FFDCEntries& ffdc)
{
PelFFDC pelFFDC;
std::for_each(ffdc.begin(), ffdc.end(), [&pelFFDC](const auto& f) {
PelFFDCfile pf;
pf.subType = std::get<ffdcSubtypePos>(f);
pf.version = std::get<ffdcVersionPos>(f);
pf.fd = std::get<ffdcFDPos>(f);
switch (std::get<ffdcFormatPos>(f))
{
case Create::FFDCFormat::JSON:
pf.format = UserDataFormat::json;
break;
case Create::FFDCFormat::CBOR:
pf.format = UserDataFormat::cbor;
break;
case Create::FFDCFormat::Text:
pf.format = UserDataFormat::text;
break;
case Create::FFDCFormat::Custom:
pf.format = UserDataFormat::custom;
break;
}
pelFFDC.push_back(pf);
});
return pelFFDC;
}
void Manager::createPEL(const std::string& message, uint32_t obmcLogID,
uint64_t timestamp,
phosphor::logging::Entry::Level severity,
const std::vector<std::string>& additionalData,
const std::vector<std::string>& associations,
const FFDCEntries& ffdc)
{
auto entry = _registry.lookup(message, rg::LookupType::name);
std::string msg;
if (entry)
{
AdditionalData ad{additionalData};
auto pelFFDC = convertToPelFFDC(ffdc);
auto pel = std::make_unique<openpower::pels::PEL>(
*entry, obmcLogID, timestamp, severity, ad, pelFFDC, *_dataIface);
_repo.add(pel);
if (_repo.sizeWarning())
{
scheduleRepoPrune();
}
auto src = pel->primarySRC();
if (src)
{
using namespace std::literals::string_literals;
auto id = getNumberString("0x%08X", pel->id());
msg = "Created PEL "s + id + " with SRC "s + (*src)->asciiString();
while (msg.back() == ' ')
{
msg.pop_back();
}
log<level::INFO>(msg.c_str());
}
}
else
{
// TODO ibm-openbmc/dev/1151: Create a new PEL for this case.
// For now, just trace it.
msg = "Event not found in PEL message registry: " + message;
log<level::INFO>(msg.c_str());
}
}
sdbusplus::message::unix_fd Manager::getPEL(uint32_t pelID)
{
Repository::LogID id{Repository::LogID::Pel(pelID)};
std::optional<int> fd;
log<level::DEBUG>("getPEL", entry("PEL_ID=0x%X", pelID));
try
{
fd = _repo.getPELFD(id);
}
catch (std::exception& e)
{
throw common_error::InternalFailure();
}
if (!fd)
{
throw common_error::InvalidArgument();
}
scheduleFDClose(*fd);
return *fd;
}
void Manager::scheduleFDClose(int fd)
{
sdeventplus::Event event = sdeventplus::Event::get_default();
_fdCloserEventSource = std::make_unique<sdeventplus::source::Defer>(
event, std::bind(std::mem_fn(&Manager::closeFD), this, fd,
std::placeholders::_1));
}
void Manager::closeFD(int fd, sdeventplus::source::EventBase& source)
{
close(fd);
_fdCloserEventSource.reset();
}
std::vector<uint8_t> Manager::getPELFromOBMCID(uint32_t obmcLogID)
{
Repository::LogID id{Repository::LogID::Obmc(obmcLogID)};
std::optional<std::vector<uint8_t>> data;
log<level::DEBUG>("getPELFromOBMCID", entry("OBMC_LOG_ID=%d", obmcLogID));
try
{
data = _repo.getPELData(id);
}
catch (std::exception& e)
{
throw common_error::InternalFailure();
}
if (!data)
{
throw common_error::InvalidArgument();
}
return *data;
}
void Manager::hostAck(uint32_t pelID)
{
Repository::LogID id{Repository::LogID::Pel(pelID)};
log<level::DEBUG>("HostAck", entry("PEL_ID=0x%X", pelID));
if (!_repo.hasPEL(id))
{
throw common_error::InvalidArgument();
}
if (_hostNotifier)
{
_hostNotifier->ackPEL(pelID);
}
}
void Manager::hostReject(uint32_t pelID, RejectionReason reason)
{
Repository::LogID id{Repository::LogID::Pel(pelID)};
log<level::DEBUG>("HostReject", entry("PEL_ID=0x%X", pelID),
entry("REASON=%d", static_cast<int>(reason)));
if (!_repo.hasPEL(id))
{
throw common_error::InvalidArgument();
}
if (reason == RejectionReason::BadPEL)
{
AdditionalData data;
data.add("BAD_ID", getNumberString("0x%08X", pelID));
_eventLogger.log("org.open_power.Logging.Error.SentBadPELToHost",
Entry::Level::Informational, data);
if (_hostNotifier)
{
_hostNotifier->setBadPEL(pelID);
}
}
else if ((reason == RejectionReason::HostFull) && _hostNotifier)
{
_hostNotifier->setHostFull(pelID);
}
}
void Manager::scheduleRepoPrune()
{
sdeventplus::Event event = sdeventplus::Event::get_default();
_repoPrunerEventSource = std::make_unique<sdeventplus::source::Defer>(
event, std::bind(std::mem_fn(&Manager::pruneRepo), this,
std::placeholders::_1));
}
void Manager::pruneRepo(sdeventplus::source::EventBase& source)
{
auto idsToDelete = _repo.prune();
// Remove the OpenBMC event logs for the PELs that were just removed.
std::for_each(idsToDelete.begin(), idsToDelete.end(),
[this](auto id) { this->_logManager.erase(id); });
_repoPrunerEventSource.reset();
}
} // namespace pels
} // namespace openpower