blob: 1654eca15017d6047cd04220556e15ae6dbcbd09 [file] [log] [blame]
/**
* Copyright © 2017 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 "watchdog.hpp"
#include <CLI/CLI.hpp>
#include <functional>
#include <iostream>
#include <optional>
#include <phosphor-logging/elog-errors.hpp>
#include <phosphor-logging/elog.hpp>
#include <phosphor-logging/log.hpp>
#include <sdbusplus/bus.hpp>
#include <sdbusplus/exception.hpp>
#include <sdbusplus/server/manager.hpp>
#include <sdeventplus/event.hpp>
#include <string>
#include <xyz/openbmc_project/Common/error.hpp>
using phosphor::watchdog::Watchdog;
using sdbusplus::xyz::openbmc_project::State::server::convertForMessage;
void printActionTargetMap(const Watchdog::ActionTargetMap& actionTargetMap)
{
std::cerr << "Action Targets:\n";
for (const auto& [action, target] : actionTargetMap)
{
std::cerr << " " << convertForMessage(action) << " -> " << target
<< "\n";
}
std::cerr << std::flush;
}
void printFallback(const Watchdog::Fallback& fallback)
{
std::cerr << "Fallback Options:\n";
std::cerr << " Action: " << convertForMessage(fallback.action) << "\n";
std::cerr << " Interval(ms): " << std::dec << fallback.interval << "\n";
std::cerr << " Always re-execute: " << std::boolalpha << fallback.always
<< "\n";
std::cerr << std::flush;
}
int main(int argc, char* argv[])
{
using namespace phosphor::logging;
using InternalFailure =
sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
CLI::App app{"Canonical openbmc host watchdog daemon"};
// Service related options
const std::string serviceGroup = "Service Options";
std::string path;
app.add_option("-p,--path", path,
"DBus Object Path. "
"Ex: /xyz/openbmc_project/state/watchdog/host0")
->required()
->group(serviceGroup);
std::string service;
app.add_option("-s,--service", service,
"DBus Service Name. "
"Ex: xyz.openbmc_project.State.Watchdog.Host")
->required()
->group(serviceGroup);
bool continueAfterTimeout{false};
app.add_flag("-c,--continue", continueAfterTimeout,
"Continue daemon after watchdog timeout")
->group(serviceGroup);
// Target related options
const std::string targetGroup = "Target Options";
std::optional<std::string> target;
app.add_option("-t,--target", target,
"Systemd unit to be called on "
"timeout for all actions but NONE. "
"Deprecated, use --action_target instead.")
->group(targetGroup);
std::vector<std::string> actionTargets;
app.add_option("-a,--action_target", actionTargets,
"Map of action to "
"systemd unit to be called on timeout if that action is "
"set for ExpireAction when the timer expires.")
->group(targetGroup);
// Fallback related options
const std::string fallbackGroup = "Fallback Options";
std::optional<std::string> fallbackAction;
auto fallbackActionOpt =
app.add_option("-f,--fallback_action", fallbackAction,
"Enables the "
"watchdog even when disabled via the dbus interface. "
"Perform this action when the fallback expires.")
->group(fallbackGroup);
std::optional<unsigned> fallbackIntervalMs;
auto fallbackIntervalOpt =
app.add_option("-i,--fallback_interval", fallbackIntervalMs,
"Enables the "
"watchdog even when disabled via the dbus interface. "
"Waits for this interval before performing the fallback "
"action.")
->group(fallbackGroup);
fallbackIntervalOpt->needs(fallbackActionOpt);
fallbackActionOpt->needs(fallbackIntervalOpt);
bool fallbackAlways{false};
app.add_flag("-e,--fallback_always", fallbackAlways,
"Enables the "
"watchdog even when disabled by the dbus interface. "
"This option is only valid with a fallback specified")
->group(fallbackGroup)
->needs(fallbackActionOpt)
->needs(fallbackIntervalOpt);
// Should we watch for postcodes
bool watchPostcodes{false};
app.add_flag("-w,--watch_postcodes", watchPostcodes,
"Should we reset the time remaining any time a postcode "
"is signaled.");
// Interval related options
uint64_t minInterval = phosphor::watchdog::DEFAULT_MIN_INTERVAL_MS;
app.add_option("-m,--min_interval", minInterval,
"Set minimum interval for watchdog in milliseconds");
// 0 to indicate to use default from PDI if not passed in
uint64_t defaultInterval = 0;
app.add_option("-d,--default_interval", defaultInterval,
"Set default interval for watchdog in milliseconds");
CLI11_PARSE(app, argc, argv);
// Put together a list of actions and associated systemd targets
// The new --action_target options take precedence over the legacy
// --target
Watchdog::ActionTargetMap actionTargetMap;
if (target)
{
actionTargetMap[Watchdog::Action::HardReset] = *target;
actionTargetMap[Watchdog::Action::PowerOff] = *target;
actionTargetMap[Watchdog::Action::PowerCycle] = *target;
}
for (const auto& actionTarget : actionTargets)
{
size_t keyValueSplit = actionTarget.find("=");
if (keyValueSplit == std::string::npos)
{
std::cerr << "Invalid action_target format, "
"expect <action>=<target>."
<< std::endl;
return 1;
}
std::string key = actionTarget.substr(0, keyValueSplit);
std::string value = actionTarget.substr(keyValueSplit + 1);
// Convert an action from a fully namespaced value
Watchdog::Action action;
try
{
action = Watchdog::convertActionFromString(key);
}
catch (const sdbusplus::exception::InvalidEnumString&)
{
std::cerr << "Bad action specified: " << key << std::endl;
return 1;
}
// Detect duplicate action target arguments
if (actionTargetMap.find(action) != actionTargetMap.end())
{
std::cerr << "Got duplicate action: " << key << std::endl;
return 1;
}
actionTargetMap[action] = std::move(value);
}
printActionTargetMap(actionTargetMap);
// Build the fallback option used for the Watchdog
std::optional<Watchdog::Fallback> maybeFallback;
if (fallbackAction)
{
Watchdog::Fallback fallback;
try
{
fallback.action =
Watchdog::convertActionFromString(*fallbackAction);
}
catch (const sdbusplus::exception::InvalidEnumString&)
{
std::cerr << "Bad fallback action specified: " << *fallbackAction
<< std::endl;
return 1;
}
fallback.interval = *fallbackIntervalMs;
fallback.always = fallbackAlways;
printFallback(fallback);
maybeFallback = std::move(fallback);
}
try
{
// Get a default event loop
auto event = sdeventplus::Event::get_default();
// Get a handle to system dbus.
auto bus = sdbusplus::bus::new_default();
// Add systemd object manager.
sdbusplus::server::manager::manager(bus, path.c_str());
// Attach the bus to sd_event to service user requests
bus.attach_event(event.get(), SD_EVENT_PRIORITY_NORMAL);
// Create a watchdog object
Watchdog watchdog(bus, path.c_str(), event, std::move(actionTargetMap),
std::move(maybeFallback), minInterval,
defaultInterval);
std::optional<sdbusplus::bus::match::match> watchPostcodeMatch;
if (watchPostcodes)
{
watchPostcodeMatch.emplace(
bus,
sdbusplus::bus::match::rules::propertiesChanged(
"/xyz/openbmc_project/state/boot/raw0",
"xyz.openbmc_project.State.Boot.Raw"),
std::bind(&Watchdog::resetTimeRemaining, std::ref(watchdog),
false));
}
// Claim the bus
bus.request_name(service.c_str());
// Loop until our timer expires and we don't want to continue
while (continueAfterTimeout || !watchdog.timerExpired())
{
// Run and never timeout
event.run(std::nullopt);
}
}
catch (InternalFailure& e)
{
phosphor::logging::commit<InternalFailure>();
// Need a coredump in the error cases.
std::terminate();
}
return 0;
}