310 lines
16 KiB
Plaintext
Executable file
310 lines
16 KiB
Plaintext
Executable file
The Linux WatchDog Timer Driver Core kernel API.
|
|
===============================================
|
|
Last reviewed: 12-Feb-2013
|
|
|
|
Wim Van Sebroeck <wim@iguana.be>
|
|
|
|
Introduction
|
|
------------
|
|
This document does not describe what a WatchDog Timer (WDT) Driver or Device is.
|
|
It also does not describe the API which can be used by user space to communicate
|
|
with a WatchDog Timer. If you want to know this then please read the following
|
|
file: Documentation/watchdog/watchdog-api.txt .
|
|
|
|
So what does this document describe? It describes the API that can be used by
|
|
WatchDog Timer Drivers that want to use the WatchDog Timer Driver Core
|
|
Framework. This framework provides all interfacing towards user space so that
|
|
the same code does not have to be reproduced each time. This also means that
|
|
a watchdog timer driver then only needs to provide the different routines
|
|
(operations) that control the watchdog timer (WDT).
|
|
|
|
The API
|
|
-------
|
|
Each watchdog timer driver that wants to use the WatchDog Timer Driver Core
|
|
must #include <linux/watchdog.h> (you would have to do this anyway when
|
|
writing a watchdog device driver). This include file contains following
|
|
register/unregister routines:
|
|
|
|
extern int watchdog_register_device(struct watchdog_device *);
|
|
extern void watchdog_unregister_device(struct watchdog_device *);
|
|
|
|
The watchdog_register_device routine registers a watchdog timer device.
|
|
The parameter of this routine is a pointer to a watchdog_device structure.
|
|
This routine returns zero on success and a negative errno code for failure.
|
|
|
|
The watchdog_unregister_device routine deregisters a registered watchdog timer
|
|
device. The parameter of this routine is the pointer to the registered
|
|
watchdog_device structure.
|
|
|
|
The watchdog subsystem includes an registration deferral mechanism,
|
|
which allows you to register an watchdog as early as you wish during
|
|
the boot process.
|
|
|
|
The watchdog device structure looks like this:
|
|
|
|
struct watchdog_device {
|
|
int id;
|
|
struct device *parent;
|
|
const struct attribute_group **groups;
|
|
const struct watchdog_info *info;
|
|
const struct watchdog_ops *ops;
|
|
const struct watchdog_governor *gov;
|
|
unsigned int bootstatus;
|
|
unsigned int timeout;
|
|
unsigned int pretimeout;
|
|
unsigned int min_timeout;
|
|
unsigned int max_timeout;
|
|
unsigned int min_hw_heartbeat_ms;
|
|
unsigned int max_hw_heartbeat_ms;
|
|
struct notifier_block reboot_nb;
|
|
struct notifier_block restart_nb;
|
|
void *driver_data;
|
|
struct watchdog_core_data *wd_data;
|
|
unsigned long status;
|
|
struct list_head deferred;
|
|
};
|
|
|
|
It contains following fields:
|
|
* id: set by watchdog_register_device, id 0 is special. It has both a
|
|
/dev/watchdog0 cdev (dynamic major, minor 0) as well as the old
|
|
/dev/watchdog miscdev. The id is set automatically when calling
|
|
watchdog_register_device.
|
|
* parent: set this to the parent device (or NULL) before calling
|
|
watchdog_register_device.
|
|
* groups: List of sysfs attribute groups to create when creating the watchdog
|
|
device.
|
|
* info: a pointer to a watchdog_info structure. This structure gives some
|
|
additional information about the watchdog timer itself. (Like it's unique name)
|
|
* ops: a pointer to the list of watchdog operations that the watchdog supports.
|
|
* gov: a pointer to the assigned watchdog device pretimeout governor or NULL.
|
|
* timeout: the watchdog timer's timeout value (in seconds).
|
|
This is the time after which the system will reboot if user space does
|
|
not send a heartbeat request if WDOG_ACTIVE is set.
|
|
* pretimeout: the watchdog timer's pretimeout value (in seconds).
|
|
* min_timeout: the watchdog timer's minimum timeout value (in seconds).
|
|
If set, the minimum configurable value for 'timeout'.
|
|
* max_timeout: the watchdog timer's maximum timeout value (in seconds),
|
|
as seen from userspace. If set, the maximum configurable value for
|
|
'timeout'. Not used if max_hw_heartbeat_ms is non-zero.
|
|
* min_hw_heartbeat_ms: Hardware limit for minimum time between heartbeats,
|
|
in milli-seconds. This value is normally 0; it should only be provided
|
|
if the hardware can not tolerate lower intervals between heartbeats.
|
|
* max_hw_heartbeat_ms: Maximum hardware heartbeat, in milli-seconds.
|
|
If set, the infrastructure will send heartbeats to the watchdog driver
|
|
if 'timeout' is larger than max_hw_heartbeat_ms, unless WDOG_ACTIVE
|
|
is set and userspace failed to send a heartbeat for at least 'timeout'
|
|
seconds. max_hw_heartbeat_ms must be set if a driver does not implement
|
|
the stop function.
|
|
* reboot_nb: notifier block that is registered for reboot notifications, for
|
|
internal use only. If the driver calls watchdog_stop_on_reboot, watchdog core
|
|
will stop the watchdog on such notifications.
|
|
* restart_nb: notifier block that is registered for machine restart, for
|
|
internal use only. If a watchdog is capable of restarting the machine, it
|
|
should define ops->restart. Priority can be changed through
|
|
watchdog_set_restart_priority.
|
|
* bootstatus: status of the device after booting (reported with watchdog
|
|
WDIOF_* status bits).
|
|
* driver_data: a pointer to the drivers private data of a watchdog device.
|
|
This data should only be accessed via the watchdog_set_drvdata and
|
|
watchdog_get_drvdata routines.
|
|
* wd_data: a pointer to watchdog core internal data.
|
|
* status: this field contains a number of status bits that give extra
|
|
information about the status of the device (Like: is the watchdog timer
|
|
running/active, or is the nowayout bit set).
|
|
* deferred: entry in wtd_deferred_reg_list which is used to
|
|
register early initialized watchdogs.
|
|
|
|
The list of watchdog operations is defined as:
|
|
|
|
struct watchdog_ops {
|
|
struct module *owner;
|
|
/* mandatory operations */
|
|
int (*start)(struct watchdog_device *);
|
|
int (*stop)(struct watchdog_device *);
|
|
/* optional operations */
|
|
int (*ping)(struct watchdog_device *);
|
|
unsigned int (*status)(struct watchdog_device *);
|
|
int (*set_timeout)(struct watchdog_device *, unsigned int);
|
|
int (*set_pretimeout)(struct watchdog_device *, unsigned int);
|
|
unsigned int (*get_timeleft)(struct watchdog_device *);
|
|
int (*restart)(struct watchdog_device *);
|
|
void (*ref)(struct watchdog_device *) __deprecated;
|
|
void (*unref)(struct watchdog_device *) __deprecated;
|
|
long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long);
|
|
};
|
|
|
|
It is important that you first define the module owner of the watchdog timer
|
|
driver's operations. This module owner will be used to lock the module when
|
|
the watchdog is active. (This to avoid a system crash when you unload the
|
|
module and /dev/watchdog is still open).
|
|
|
|
Some operations are mandatory and some are optional. The mandatory operations
|
|
are:
|
|
* start: this is a pointer to the routine that starts the watchdog timer
|
|
device.
|
|
The routine needs a pointer to the watchdog timer device structure as a
|
|
parameter. It returns zero on success or a negative errno code for failure.
|
|
|
|
Not all watchdog timer hardware supports the same functionality. That's why
|
|
all other routines/operations are optional. They only need to be provided if
|
|
they are supported. These optional routines/operations are:
|
|
* stop: with this routine the watchdog timer device is being stopped.
|
|
The routine needs a pointer to the watchdog timer device structure as a
|
|
parameter. It returns zero on success or a negative errno code for failure.
|
|
Some watchdog timer hardware can only be started and not be stopped. A
|
|
driver supporting such hardware does not have to implement the stop routine.
|
|
If a driver has no stop function, the watchdog core will set WDOG_HW_RUNNING
|
|
and start calling the driver's keepalive pings function after the watchdog
|
|
device is closed.
|
|
If a watchdog driver does not implement the stop function, it must set
|
|
max_hw_heartbeat_ms.
|
|
* ping: this is the routine that sends a keepalive ping to the watchdog timer
|
|
hardware.
|
|
The routine needs a pointer to the watchdog timer device structure as a
|
|
parameter. It returns zero on success or a negative errno code for failure.
|
|
Most hardware that does not support this as a separate function uses the
|
|
start function to restart the watchdog timer hardware. And that's also what
|
|
the watchdog timer driver core does: to send a keepalive ping to the watchdog
|
|
timer hardware it will either use the ping operation (when available) or the
|
|
start operation (when the ping operation is not available).
|
|
(Note: the WDIOC_KEEPALIVE ioctl call will only be active when the
|
|
WDIOF_KEEPALIVEPING bit has been set in the option field on the watchdog's
|
|
info structure).
|
|
* status: this routine checks the status of the watchdog timer device. The
|
|
status of the device is reported with watchdog WDIOF_* status flags/bits.
|
|
WDIOF_MAGICCLOSE and WDIOF_KEEPALIVEPING are reported by the watchdog core;
|
|
it is not necessary to report those bits from the driver. Also, if no status
|
|
function is provided by the driver, the watchdog core reports the status bits
|
|
provided in the bootstatus variable of struct watchdog_device.
|
|
* set_timeout: this routine checks and changes the timeout of the watchdog
|
|
timer device. It returns 0 on success, -EINVAL for "parameter out of range"
|
|
and -EIO for "could not write value to the watchdog". On success this
|
|
routine should set the timeout value of the watchdog_device to the
|
|
achieved timeout value (which may be different from the requested one
|
|
because the watchdog does not necessarily have a 1 second resolution).
|
|
Drivers implementing max_hw_heartbeat_ms set the hardware watchdog heartbeat
|
|
to the minimum of timeout and max_hw_heartbeat_ms. Those drivers set the
|
|
timeout value of the watchdog_device either to the requested timeout value
|
|
(if it is larger than max_hw_heartbeat_ms), or to the achieved timeout value.
|
|
(Note: the WDIOF_SETTIMEOUT needs to be set in the options field of the
|
|
watchdog's info structure).
|
|
If the watchdog driver does not have to perform any action but setting the
|
|
watchdog_device.timeout, this callback can be omitted.
|
|
If set_timeout is not provided but, WDIOF_SETTIMEOUT is set, the watchdog
|
|
infrastructure updates the timeout value of the watchdog_device internally
|
|
to the requested value.
|
|
If the pretimeout feature is used (WDIOF_PRETIMEOUT), then set_timeout must
|
|
also take care of checking if pretimeout is still valid and set up the timer
|
|
accordingly. This can't be done in the core without races, so it is the
|
|
duty of the driver.
|
|
* set_pretimeout: this routine checks and changes the pretimeout value of
|
|
the watchdog. It is optional because not all watchdogs support pretimeout
|
|
notification. The timeout value is not an absolute time, but the number of
|
|
seconds before the actual timeout would happen. It returns 0 on success,
|
|
-EINVAL for "parameter out of range" and -EIO for "could not write value to
|
|
the watchdog". A value of 0 disables pretimeout notification.
|
|
(Note: the WDIOF_PRETIMEOUT needs to be set in the options field of the
|
|
watchdog's info structure).
|
|
If the watchdog driver does not have to perform any action but setting the
|
|
watchdog_device.pretimeout, this callback can be omitted. That means if
|
|
set_pretimeout is not provided but WDIOF_PRETIMEOUT is set, the watchdog
|
|
infrastructure updates the pretimeout value of the watchdog_device internally
|
|
to the requested value.
|
|
* get_timeleft: this routines returns the time that's left before a reset.
|
|
* restart: this routine restarts the machine. It returns 0 on success or a
|
|
negative errno code for failure.
|
|
* ioctl: if this routine is present then it will be called first before we do
|
|
our own internal ioctl call handling. This routine should return -ENOIOCTLCMD
|
|
if a command is not supported. The parameters that are passed to the ioctl
|
|
call are: watchdog_device, cmd and arg.
|
|
|
|
The 'ref' and 'unref' operations are no longer used and deprecated.
|
|
|
|
The status bits should (preferably) be set with the set_bit and clear_bit alike
|
|
bit-operations. The status bits that are defined are:
|
|
* WDOG_ACTIVE: this status bit indicates whether or not a watchdog timer device
|
|
is active or not from user perspective. User space is expected to send
|
|
heartbeat requests to the driver while this flag is set.
|
|
* WDOG_NO_WAY_OUT: this bit stores the nowayout setting for the watchdog.
|
|
If this bit is set then the watchdog timer will not be able to stop.
|
|
* WDOG_HW_RUNNING: Set by the watchdog driver if the hardware watchdog is
|
|
running. The bit must be set if the watchdog timer hardware can not be
|
|
stopped. The bit may also be set if the watchdog timer is running after
|
|
booting, before the watchdog device is opened. If set, the watchdog
|
|
infrastructure will send keepalives to the watchdog hardware while
|
|
WDOG_ACTIVE is not set.
|
|
Note: when you register the watchdog timer device with this bit set,
|
|
then opening /dev/watchdog will skip the start operation but send a keepalive
|
|
request instead.
|
|
|
|
To set the WDOG_NO_WAY_OUT status bit (before registering your watchdog
|
|
timer device) you can either:
|
|
* set it statically in your watchdog_device struct with
|
|
.status = WATCHDOG_NOWAYOUT_INIT_STATUS,
|
|
(this will set the value the same as CONFIG_WATCHDOG_NOWAYOUT) or
|
|
* use the following helper function:
|
|
static inline void watchdog_set_nowayout(struct watchdog_device *wdd, int nowayout)
|
|
|
|
Note: The WatchDog Timer Driver Core supports the magic close feature and
|
|
the nowayout feature. To use the magic close feature you must set the
|
|
WDIOF_MAGICCLOSE bit in the options field of the watchdog's info structure.
|
|
The nowayout feature will overrule the magic close feature.
|
|
|
|
To get or set driver specific data the following two helper functions should be
|
|
used:
|
|
|
|
static inline void watchdog_set_drvdata(struct watchdog_device *wdd, void *data)
|
|
static inline void *watchdog_get_drvdata(struct watchdog_device *wdd)
|
|
|
|
The watchdog_set_drvdata function allows you to add driver specific data. The
|
|
arguments of this function are the watchdog device where you want to add the
|
|
driver specific data to and a pointer to the data itself.
|
|
|
|
The watchdog_get_drvdata function allows you to retrieve driver specific data.
|
|
The argument of this function is the watchdog device where you want to retrieve
|
|
data from. The function returns the pointer to the driver specific data.
|
|
|
|
To initialize the timeout field, the following function can be used:
|
|
|
|
extern int watchdog_init_timeout(struct watchdog_device *wdd,
|
|
unsigned int timeout_parm, struct device *dev);
|
|
|
|
The watchdog_init_timeout function allows you to initialize the timeout field
|
|
using the module timeout parameter or by retrieving the timeout-sec property from
|
|
the device tree (if the module timeout parameter is invalid). Best practice is
|
|
to set the default timeout value as timeout value in the watchdog_device and
|
|
then use this function to set the user "preferred" timeout value.
|
|
This routine returns zero on success and a negative errno code for failure.
|
|
|
|
To disable the watchdog on reboot, the user must call the following helper:
|
|
|
|
static inline void watchdog_stop_on_reboot(struct watchdog_device *wdd);
|
|
|
|
To disable the watchdog when unregistering the watchdog, the user must call
|
|
the following helper. Note that this will only stop the watchdog if the
|
|
nowayout flag is not set.
|
|
|
|
static inline void watchdog_stop_on_unregister(struct watchdog_device *wdd);
|
|
|
|
To change the priority of the restart handler the following helper should be
|
|
used:
|
|
|
|
void watchdog_set_restart_priority(struct watchdog_device *wdd, int priority);
|
|
|
|
User should follow the following guidelines for setting the priority:
|
|
* 0: should be called in last resort, has limited restart capabilities
|
|
* 128: default restart handler, use if no other handler is expected to be
|
|
available, and/or if restart is sufficient to restart the entire system
|
|
* 255: highest priority, will preempt all other restart handlers
|
|
|
|
To raise a pretimeout notification, the following function should be used:
|
|
|
|
void watchdog_notify_pretimeout(struct watchdog_device *wdd)
|
|
|
|
The function can be called in the interrupt context. If watchdog pretimeout
|
|
governor framework (kbuild CONFIG_WATCHDOG_PRETIMEOUT_GOV symbol) is enabled,
|
|
an action is taken by a preconfigured pretimeout governor preassigned to
|
|
the watchdog device. If watchdog pretimeout governor framework is not
|
|
enabled, watchdog_notify_pretimeout() prints a notification message to
|
|
the kernel log buffer.
|