1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
#include <chrono>
#include <phosphor-logging/log.hpp>
#include "watchdog.hpp"
namespace phosphor
{
namespace watchdog
{
using namespace std::chrono;
using namespace std::chrono_literals;
using namespace phosphor::logging;
// systemd service to kick start a target.
constexpr auto SYSTEMD_SERVICE = "org.freedesktop.systemd1";
constexpr auto SYSTEMD_ROOT = "/org/freedesktop/systemd1";
constexpr auto SYSTEMD_INTERFACE = "org.freedesktop.systemd1.Manager";
// Enable or disable watchdog
bool Watchdog::enabled(bool value)
{
if (this->enabled() != value)
{
if (value)
{
// Start ONESHOT timer. Timer handles all in usec
auto usec = duration_cast<microseconds>(
milliseconds(this->interval()));
// Update new expiration
timer.start(usec);
// Enable timer
timer.setEnabled<std::true_type>();
log<level::INFO>("watchdog: enabled and started",
entry("INTERVAL=%llu", this->interval()));
}
else
{
timer.setEnabled<std::false_type>();
timer.clearExpired();
log<level::INFO>("watchdog: disabled");
}
}
return WatchdogInherits::enabled(value);
}
// Get the remaining time before timer expires.
// If the timer is disabled, returns 0
uint64_t Watchdog::timeRemaining() const
{
uint64_t timeRemain = 0;
// timer may have already expired and disabled
if (timerEnabled())
{
// the one-shot timer does not expire yet
auto expiry = duration_cast<milliseconds>(
timer.getRemaining());
// convert to msec per interface expectation.
auto timeNow = duration_cast<milliseconds>(
Timer::getCurrentTime());
// Its possible that timer may have expired by now.
// So need to cross verify.
timeRemain = (expiry > timeNow) ?
(expiry - timeNow).count() : 0;
}
return timeRemain;
}
// Reset the timer to a new expiration value
uint64_t Watchdog::timeRemaining(uint64_t value)
{
if (!timerEnabled())
{
// We don't need to update the timer because it is off
return 0;
}
// Update new expiration
auto usec = duration_cast<microseconds>(milliseconds(value));
timer.start(usec);
// Update Base class data.
return WatchdogInherits::timeRemaining(value);
}
// Optional callback function on timer expiration
void Watchdog::timeOutHandler()
{
auto action = expireAction();
auto target = actionTargets.find(action);
if (target == actionTargets.end())
{
log<level::INFO>("watchdog: Timed out with no target",
entry("ACTION=%s", convertForMessage(action).c_str()));
return;
}
auto method = bus.new_method_call(SYSTEMD_SERVICE,
SYSTEMD_ROOT,
SYSTEMD_INTERFACE,
"StartUnit");
method.append(target->second);
method.append("replace");
log<level::INFO>("watchdog: Timed out",
entry("ACTION=%s", convertForMessage(action).c_str()),
entry("TARGET=%s", target->second.c_str()));
bus.call_noreply(method);
}
} // namespace watchdog
} // namepsace phosphor
|
