[systemd-devel] [PATCH v3 1/4] service: add watchdog timestamp

Michael Olbrich m.olbrich at pengutronix.de
Wed Feb 1 08:17:12 PST 2012


This patch adds WatchdogTimestamp[Monotonic] to the systemd service
D-Bus API. The timestamp is updated to the current time when the
service calls 'sd_nofity("WATCHDOG=1\n")'.
Using a timestamp instead of an 'alive' flag has two advantages:
1. No timeout is needed to define when a service is no longer alive.
   This simplifies both configuration (no timeout value) and
   implementation (no timeout event).
2. It is more robust. A 'dead' service might not be detected should
    systemd 'forget' to reset an 'alive' flag. It is much less likely
    to get a valid new timestamp if a service died.
---
changes in v2:
 - adapt to changes from "d200735 dbus: more efficient implementation of properties"
 - serialize timestamp (needed for correct daemon-reload/daemon-reload handling)

 man/sd_notify.xml       |   12 ++++++++++++
 src/dbus-service.c      |    5 +++++
 src/service.c           |   25 +++++++++++++++++++++++++
 src/service.h           |    2 ++
 src/systemd/sd-daemon.h |    5 +++++
 5 files changed, 49 insertions(+), 0 deletions(-)

diff --git a/man/sd_notify.xml b/man/sd_notify.xml
index 0209146..9797a5f 100644
--- a/man/sd_notify.xml
+++ b/man/sd_notify.xml
@@ -151,6 +151,18 @@
                                 itself. Example:
                                 "MAINPID=4711"</para></listitem>
                         </varlistentry>
+
+                        <varlistentry>
+                                <term>WATCHDOG=1</term>
+
+                                <listitem><para>Tells systemd to
+                                update the watchdog timestamp.
+                                Services using this feature should do
+                                this in regular intervals. A watchdog
+                                framework can use the timestamps to
+                                detect failed
+                                services.</para></listitem>
+                        </varlistentry>
                 </variablelist>
 
                 <para>It is recommended to prefix variable names that
diff --git a/src/dbus-service.c b/src/dbus-service.c
index e1f6370..d7529ec 100644
--- a/src/dbus-service.c
+++ b/src/dbus-service.c
@@ -43,6 +43,8 @@
         "  <property name=\"NotifyAccess\" type=\"s\" access=\"read\"/>\n" \
         "  <property name=\"RestartUSec\" type=\"t\" access=\"read\"/>\n" \
         "  <property name=\"TimeoutUSec\" type=\"t\" access=\"read\"/>\n" \
+        "  <property name=\"WatchdogTimestamp\" type=\"t\" access=\"read\"/>\n" \
+        "  <property name=\"WatchdogTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
         BUS_EXEC_COMMAND_INTERFACE("ExecStartPre")                      \
         BUS_EXEC_COMMAND_INTERFACE("ExecStart")                         \
         BUS_EXEC_COMMAND_INTERFACE("ExecStartPost")                     \
@@ -86,6 +88,7 @@ const char bus_service_invalidating_properties[] =
         "ExecStop\0"
         "ExecStopPost\0"
         "ExecMain\0"
+        "WatchdogTimestamp\0"
         "MainPID\0"
         "ControlPID\0"
         "StatusText\0";
@@ -112,6 +115,8 @@ static const BusProperty bus_service_properties[] = {
         { "NotifyAccess",           bus_service_append_notify_access, "s", offsetof(Service, notify_access)             },
         { "RestartUSec",            bus_property_append_usec,         "t", offsetof(Service, restart_usec)              },
         { "TimeoutUSec",            bus_property_append_usec,         "t", offsetof(Service, timeout_usec)              },
+        { "WatchdogTimestamp",      bus_property_append_usec,         "t", offsetof(Service, watchdog_timestamp.realtime)},
+        { "WatchdogTimestampMonotonic",bus_property_append_usec,      "t", offsetof(Service, watchdog_timestamp.monotonic)},
         BUS_EXEC_COMMAND_PROPERTY("ExecStartPre",  offsetof(Service, exec_command[SERVICE_EXEC_START_PRE]),  true ),
         BUS_EXEC_COMMAND_PROPERTY("ExecStart",     offsetof(Service, exec_command[SERVICE_EXEC_START]),      true ),
         BUS_EXEC_COMMAND_PROPERTY("ExecStartPost", offsetof(Service, exec_command[SERVICE_EXEC_START_POST]), true ),
diff --git a/src/service.c b/src/service.c
index 4dcd306..e107179 100644
--- a/src/service.c
+++ b/src/service.c
@@ -205,6 +205,19 @@ static void service_connection_unref(Service *s) {
         unit_ref_unset(&s->accept_socket);
 }
 
+static void service_stop_watchdog(Service *s) {
+        assert(s);
+
+        s->watchdog_timestamp.realtime = 0;
+        s->watchdog_timestamp.monotonic = 0;
+}
+
+static void service_reset_watchdog(Service *s) {
+        assert(s);
+
+        dual_timestamp_get(&s->watchdog_timestamp);
+}
+
 static void service_done(Unit *u) {
         Service *s = SERVICE(u);
 
@@ -1476,6 +1489,9 @@ static void service_set_state(Service *s, ServiceState state) {
                 service_connection_unref(s);
         }
 
+        if (state == SERVICE_STOP)
+                service_stop_watchdog(s);
+
         /* For the inactive states unit_notify() will trim the cgroup,
          * but for exit we have to do that ourselves... */
         if (state == SERVICE_EXITED && UNIT(s)->manager->n_reloading <= 0)
@@ -2411,6 +2427,9 @@ static int service_serialize(Unit *u, FILE *f, FDSet *fds) {
                         unit_serialize_item_format(u, f, "main-exec-status-status", "%i", s->main_exec_status.status);
                 }
         }
+        if (dual_timestamp_is_set(&s->watchdog_timestamp)) {
+                dual_timestamp_serialize(f, "watchdog-timestamp", &s->watchdog_timestamp);
+        }
 
         return 0;
 }
@@ -2511,6 +2530,8 @@ static int service_deserialize_item(Unit *u, const char *key, const char *value,
                 dual_timestamp_deserialize(value, &s->main_exec_status.start_timestamp);
         else if (streq(key, "main-exec-status-exit"))
                 dual_timestamp_deserialize(value, &s->main_exec_status.exit_timestamp);
+        else if (streq(key, "watchdog-timestamp"))
+                dual_timestamp_deserialize(value, &s->watchdog_timestamp);
         else
                 log_debug("Unknown serialization key '%s'", key);
 
@@ -3069,6 +3090,10 @@ static void service_notify_message(Unit *u, pid_t pid, char **tags) {
                 }
 
         }
+        if (strv_find(tags, "WATCHDOG=1")) {
+                log_debug("%s: got WATCHDOG=1", u->id);
+                service_reset_watchdog(s);
+        }
 
         /* Notify clients about changed status or main pid */
         unit_add_to_dbus_queue(u);
diff --git a/src/service.h b/src/service.h
index 0b4f8be..dbae68b 100644
--- a/src/service.h
+++ b/src/service.h
@@ -100,6 +100,8 @@ struct Service {
         usec_t restart_usec;
         usec_t timeout_usec;
 
+        dual_timestamp watchdog_timestamp;
+
         ExecCommand* exec_command[_SERVICE_EXEC_COMMAND_MAX];
         ExecContext exec_context;
 
diff --git a/src/systemd/sd-daemon.h b/src/systemd/sd-daemon.h
index eb2a606..7b664bf 100644
--- a/src/systemd/sd-daemon.h
+++ b/src/systemd/sd-daemon.h
@@ -217,6 +217,11 @@ int sd_is_mq(int fd, const char *path);
      MAINPID=...  The main pid of a daemon, in case systemd did not
                   fork off the process itself. Example: "MAINPID=4711"
 
+     WATCHDOG=1   Tells systemd to update the watchdog timestamp.
+                  Services using this feature should do this in
+                  regular intervals. A watchdog framework can use the
+                  timestamps to detect failed services.
+
   Daemons can choose to send additional variables. However, it is
   recommended to prefix variable names not listed above with X_.
 
-- 
1.7.7.3



More information about the systemd-devel mailing list