# sd_event_set_watchdog

## NAME



           sd_event_set_watchdog, sd_event_get_watchdog - Enable event loop
           watchdog support
    


## SYNOPSIS



           **#include <systemd/sd-event.h>**
    
           **int sd_event_set_watchdog(sd_event ***_event_**, int b);**
    
           **int sd_event_get_watchdog(sd_event ***_event_**);**
    


## DESCRIPTION



           **sd_event_set_watchdog()** may be used to enable or disable automatic
           watchdog notification support in the event loop object specified
           in the _event_ parameter. Specifically, depending on the _b_ boolean
           argument this will make sure the event loop wakes up in regular
           intervals and sends watchdog notification messages to the service
           manager, if this was requested by the service manager. Watchdog
           support is determined with sd_watchdog_enabled(3), and watchdog
           messages are sent with sd_notify(3). See the _WatchdogSec=_ setting
           in systemd.service(5) for details on how to enable watchdog
           support for a service and the protocol used. The wake-up interval
           is chosen as half the watchdog timeout declared by the service
           manager via the _$WATCHDOG_USEC_ environment variable. If the
           service manager did not request watchdog notifications, or if the
           process was not invoked by the service manager this call with a
           true _b_ parameter executes no operation. Passing a false _b_
           parameter will disable the automatic sending of watchdog
           notification messages if it was enabled before. Newly allocated
           event loop objects have this feature disabled.
    
           The first watchdog notification message is sent immediately when
           **sd_event_set_watchdog()** is invoked with a true _b_ parameter.
    
           The watchdog logic is designed to allow the service manager to
           automatically detect services that ceased processing of incoming
           events, and thus appear "hung". Watchdog notifications are sent
           out only at the beginning of each event loop iteration. If an
           event source dispatch function blocks for an excessively long time
           and does not return execution to the event loop quickly, this
           might hence cause the notification message to be delayed, and
           possibly result in abnormal program termination, as configured in
           the service unit file.
    
           **sd_event_get_watchdog()** may be used to determine whether watchdog
           support was previously requested by a call to
           **sd_event_set_watchdog()** with a true _b_ parameter and successfully
           enabled.
    


## RETURN VALUE



           On success, **sd_event_set_watchdog()** and **sd_event_get_watchdog()**
           return a non-zero positive integer if the service manager
           requested watchdog support and watchdog support was successfully
           enabled. They return zero if the service manager did not request
           watchdog support, or if watchdog support was explicitly disabled
           with a false _b_ parameter. On failure, they return a negative
           errno-style error code.
    
       **Errors**
           Returned errors may indicate the following problems:
    
           **-ECHILD**
               The event loop has been created in a different process,
               library or module instance.
    
           **-EINVAL**
               The passed event loop object was invalid.
    


## NOTES



           Functions described here are available as a shared library, which
           can be compiled against and linked to with the
           **libsystemd pkg-config**(1) file.
    
           The code described here uses getenv(3), which is declared to be
           not multi-thread-safe. This means that the code calling the
           functions described here must not call setenv(3) from a parallel
           thread. It is recommended to only do calls to **setenv()** from an
           early phase of the program when no other threads have been
           started.
    


* * *