[1/7] watchdog: add watchdog pretimeout framework

Message ID	1464183151-4912-2-git-send-email-wsa@the-dreams.de (mailing list archive)
State	Accepted
Delegated to:	Geert Uytterhoeven
Headers	show Return-Path: <linux-renesas-soc-owner@kernel.org> From: Wolfram Sang <wsa@the-dreams.de> To: linux-watchdog@vger.kernel.org Cc: Wolfram Sang <wsa@the-dreams.de>, linux-renesas-soc@vger.kernel.org, Guenter Roeck <linux@roeck-us.net>, Vladimir Zapolskiy <vladimir_zapolskiy@mentor.com>, Robin Gong <b38343@freescale.com> Subject: [PATCH 1/7] watchdog: add watchdog pretimeout framework Date: Wed, 25 May 2016 15:32:25 +0200 Message-Id: <1464183151-4912-2-git-send-email-wsa@the-dreams.de> In-Reply-To: <1464183151-4912-1-git-send-email-wsa@the-dreams.de> References: <1464183151-4912-1-git-send-email-wsa@the-dreams.de> Sender: linux-renesas-soc-owner@vger.kernel.org Precedence: bulk

diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig index 3902c9ca7f099d..909d1021de5cbc 100644 --- a/drivers/watchdog/Kconfig +++ b/drivers/watchdog/Kconfig @@ -1774,4 +1774,12 @@ config USBPCWATCHDOG Most people will say N. +comment "Watchdog Pretimeout Governors" + +config WATCHDOG_PRETIMEOUT_GOV + bool "Enable watchdog pretimeout governors" + default n + help + The option allows to select watchdog pretimeout governors. + endif # WATCHDOG diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile index 2cbc9709852d0e..820860cf3e8d62 100644 --- a/drivers/watchdog/Makefile +++ b/drivers/watchdog/Makefile @@ -3,8 +3,10 @@ # # The WatchDog Timer Driver Core. -watchdog-objs += watchdog_core.o watchdog_dev.o -obj-$(CONFIG_WATCHDOG_CORE) += watchdog.o +obj-$(CONFIG_WATCHDOG_CORE) += watchdog.o + +watchdog-y += watchdog_core.o watchdog_dev.o +watchdog-$(CONFIG_WATCHDOG_PRETIMEOUT_GOV) += watchdog_pretimeout.o # Only one watchdog can succeed. We probe the ISA/PCI/USB based # watchdog-cards first, then the architecture specific watchdog diff --git a/drivers/watchdog/watchdog_dev.c b/drivers/watchdog/watchdog_dev.c index 3595cffa24ea49..5d028f94a90743 100644 --- a/drivers/watchdog/watchdog_dev.c +++ b/drivers/watchdog/watchdog_dev.c @@ -49,6 +49,7 @@ #include <linux/uaccess.h> /* For copy_to_user/put_user/... */ #include "watchdog_core.h" +#include "watchdog_pretimeout.h" /* * struct watchdog_core_data - watchdog core internal data @@ -911,6 +912,12 @@ int watchdog_dev_register(struct watchdog_device *wdd) return PTR_ERR(dev); } + ret = watchdog_register_pretimeout(wdd, dev); + if (ret) { + device_destroy(&watchdog_class, devno); + watchdog_cdev_unregister(wdd); + } + return ret; } @@ -924,6 +931,7 @@ int watchdog_dev_register(struct watchdog_device *wdd) void watchdog_dev_unregister(struct watchdog_device *wdd) { + watchdog_unregister_pretimeout(wdd); device_destroy(&watchdog_class, wdd->wd_data->cdev.dev); watchdog_cdev_unregister(wdd); } diff --git a/drivers/watchdog/watchdog_pretimeout.c b/drivers/watchdog/watchdog_pretimeout.c new file mode 100644 index 00000000000000..87a10ebeaacc7e --- /dev/null +++ b/drivers/watchdog/watchdog_pretimeout.c @@ -0,0 +1,269 @@ +/* + * Watchdog pretimout governor framework + * + * Copyright (C) 2015 Mentor Graphics + * Copyright (C) 2016 Renesas Electronics Corporation + * Copyright (C) 2016 Sang Engineering, Wolfram Sang + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + */ + +#include <linux/module.h> +#include <linux/slab.h> +#include <linux/watchdog.h> + +#include "watchdog_pretimeout.h" + +/* The mutex protects governor list and serializes external interfaces */ +static DEFINE_MUTEX(governor_lock); + +/* List of registered watchdog pretimeout governors */ +static LIST_HEAD(governor_list); + +/* The spinlock protects wdd->gov */ +static DEFINE_SPINLOCK(pretimeout_lock); + +struct governor_priv { + struct watchdog_governor *gov; + bool is_default; + struct list_head entry; +}; + +static struct governor_priv *find_governor_by_name(const char *gov_name) +{ + struct governor_priv *priv; + + list_for_each_entry(priv, &governor_list, entry) + if (!strncmp(gov_name, priv->gov->name, WATCHDOG_GOV_NAME_LEN)) + return priv; + + return NULL; +} + +static struct watchdog_governor *find_default_governor(void) +{ + struct governor_priv *priv; + + list_for_each_entry(priv, &governor_list, entry) + if (priv->is_default) + return priv->gov; + + return NULL; +} + +void watchdog_notify_pretimeout(struct watchdog_device *wdd) +{ + unsigned long flags; + + if (!wdd) + return; + + spin_lock_irqsave(&pretimeout_lock, flags); + + if (wdd->gov) + wdd->gov->pretimeout(wdd); + + spin_unlock_irqrestore(&pretimeout_lock, flags); +} +EXPORT_SYMBOL_GPL(watchdog_notify_pretimeout); + +int watchdog_register_governor(struct watchdog_governor *gov) +{ + struct governor_priv *priv; + + if (!gov || !gov->pretimeout || strlen(gov->name) >= WATCHDOG_GOV_NAME_LEN) + return -EINVAL; + + priv = kzalloc(sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + mutex_lock(&governor_lock); + + if (find_governor_by_name(gov->name)) { + kfree(priv); + mutex_unlock(&governor_lock); + return -EBUSY; + } + + priv->gov = gov; + + if (!strncmp(WATCHDOG_PRETIMEOUT_DEFAULT_GOV, + gov->name, WATCHDOG_GOV_NAME_LEN)) { + priv->is_default = true; + } + + list_add(&priv->entry, &governor_list); + + mutex_unlock(&governor_lock); + + return 0; +} +EXPORT_SYMBOL_GPL(watchdog_register_governor); + +void watchdog_unregister_governor(struct watchdog_governor *gov) +{ + struct governor_priv *priv; + + if (!gov) + return; + + mutex_lock(&governor_lock); + + list_for_each_entry(priv, &governor_list, entry) { + if (priv->gov == gov) { + list_del(&priv->entry); + kfree(priv); + break; + } + } + + mutex_unlock(&governor_lock); +} +EXPORT_SYMBOL_GPL(watchdog_unregister_governor); + +static ssize_t pretimeout_governor_store(struct device *dev, + struct device_attribute *attr, + const char *buf, size_t count) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + struct governor_priv *priv; + + mutex_lock(&governor_lock); + + priv = find_governor_by_name(buf); + if (!priv) { + mutex_unlock(&governor_lock); + return -EINVAL; + } + + if (!try_module_get(priv->gov->owner)) { + mutex_unlock(&governor_lock); + return -ENODEV; + } + + spin_lock_irq(&pretimeout_lock); + if (wdd->gov) + module_put(wdd->gov->owner); + wdd->gov = priv->gov; + spin_unlock_irq(&pretimeout_lock); + + mutex_unlock(&governor_lock); + + return count; +} + +static ssize_t pretimeout_governor_show(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct watchdog_device *wdd = dev_get_drvdata(dev); + char gov_name[WATCHDOG_GOV_NAME_LEN] = { 0 }; + int count; + + mutex_lock(&governor_lock); + + spin_lock_irq(&pretimeout_lock); + if (wdd->gov) + strncpy(gov_name, wdd->gov->name, WATCHDOG_GOV_NAME_LEN); + spin_unlock_irq(&pretimeout_lock); + + count = sprintf(buf, "%s\n", gov_name); + + mutex_unlock(&governor_lock); + + return count; +} +static DEVICE_ATTR_RW(pretimeout_governor); + +static ssize_t pretimeout_available_governors_show(struct device *dev, + struct device_attribute *devattr, char *buf) +{ + struct governor_priv *priv; + int count = 0; + + mutex_lock(&governor_lock); + + list_for_each_entry(priv, &governor_list, entry) + count += sprintf(buf + count, "%s\n", priv->gov->name); + + mutex_unlock(&governor_lock); + + return count; +} +static DEVICE_ATTR_RO(pretimeout_available_governors); + +static struct attribute *wdd_pretimeout_attrs[] = { + &dev_attr_pretimeout_governor.attr, + &dev_attr_pretimeout_available_governors.attr, + NULL, +}; + +static umode_t wdd_pretimeout_attr_is_visible(struct kobject *kobj, + struct attribute *attr, int n) +{ + struct device *dev = container_of(kobj, struct device, kobj); + struct watchdog_device *wdd = dev_get_drvdata(dev); + + if (wdd->info->options & WDIOF_PRETIMEOUT) + return attr->mode; + + return 0; +} + +static const struct attribute_group wdd_pretimeout_group = { + .is_visible = wdd_pretimeout_attr_is_visible, + .attrs = wdd_pretimeout_attrs, +}; + +static const struct attribute_group *wdd_pretimeout_groups[] = { + &wdd_pretimeout_group, + NULL, +}; + +int watchdog_register_pretimeout(struct watchdog_device *wdd, struct device *dev) +{ + struct watchdog_governor *gov; + int ret; + + if (!(wdd->info->options & WDIOF_PRETIMEOUT)) + return 0; + + ret = sysfs_create_groups(&dev->kobj, wdd_pretimeout_groups); + if (ret) + return ret; + + mutex_lock(&governor_lock); + gov = find_default_governor(); + if (gov && !try_module_get(gov->owner)) { + mutex_unlock(&governor_lock); + return -ENODEV; + } + + spin_lock_irq(&pretimeout_lock); + wdd->gov = gov; + spin_unlock_irq(&pretimeout_lock); + + mutex_unlock(&governor_lock); + + return 0; +} + +void watchdog_unregister_pretimeout(struct watchdog_device *wdd) +{ + if (!(wdd->info->options & WDIOF_PRETIMEOUT)) + return; + + spin_lock_irq(&pretimeout_lock); + if (wdd->gov) + module_put(wdd->gov->owner); + wdd->gov = NULL; + spin_unlock_irq(&pretimeout_lock); +} + +MODULE_AUTHOR("Vladimir Zapolskiy <vladimir_zapolskiy@mentor.com>"); +MODULE_DESCRIPTION("Watchdog pretimeout governor framework"); +MODULE_LICENSE("GPL"); diff --git a/drivers/watchdog/watchdog_pretimeout.h b/drivers/watchdog/watchdog_pretimeout.h new file mode 100644 index 00000000000000..38965cdd23bebe --- /dev/null +++ b/drivers/watchdog/watchdog_pretimeout.h @@ -0,0 +1,35 @@ +#ifndef __WATCHDOG_PRETIMEOUT_H +#define __WATCHDOG_PRETIMEOUT_H + +#define WATCHDOG_GOV_NAME_LEN 20 + +struct module; +struct watchdog_device; + +struct watchdog_governor { + const char name[WATCHDOG_GOV_NAME_LEN]; + void (*pretimeout)(struct watchdog_device *wdd); + struct module *owner; +}; + +/* Interfaces to watchdog pretimeout governors */ +int watchdog_register_governor(struct watchdog_governor *gov); +void watchdog_unregister_governor(struct watchdog_governor *gov); + +/* Interfaces to watchdog_core.c */ +#ifdef CONFIG_WATCHDOG_PRETIMEOUT_GOV + +#define WATCHDOG_PRETIMEOUT_DEFAULT_GOV "none" + +int watchdog_register_pretimeout(struct watchdog_device *wdd, struct device *dev); +void watchdog_unregister_pretimeout(struct watchdog_device *wdd); +#else +static inline int watchdog_register_pretimeout(struct watchdog_device *wdd, + struct device *dev) +{ + return 0; +} +static inline void watchdog_unregister_pretimeout(struct watchdog_device *wdd) {} +#endif + +#endif diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h index 51732d6c9555de..4b2fa45370fceb 100644 --- a/include/linux/watchdog.h +++ b/include/linux/watchdog.h @@ -19,6 +19,7 @@ struct watchdog_ops; struct watchdog_device; struct watchdog_core_data; +struct watchdog_governor; /** struct watchdog_ops - The watchdog-devices operations * @@ -59,6 +60,7 @@ struct watchdog_ops { * watchdog device. * @info: Pointer to a watchdog_info structure. * @ops: Pointer to the list of watchdog operations. + * @gov: Pointer to watchdog pretimeout governor. * @bootstatus: Status of the watchdog device at boot. * @timeout: The watchdog devices timeout value (in seconds). * @min_timeout:The watchdog devices minimum timeout value (in seconds). @@ -93,6 +95,7 @@ struct watchdog_device { const struct attribute_group **groups; const struct watchdog_info *info; const struct watchdog_ops *ops; + struct watchdog_governor *gov; unsigned int bootstatus; unsigned int timeout; unsigned int min_timeout; @@ -180,4 +183,11 @@ extern int watchdog_init_timeout(struct watchdog_device *wdd, extern int watchdog_register_device(struct watchdog_device *); extern void watchdog_unregister_device(struct watchdog_device *); +/* drivers/watchdog/watchdog_pretimeout.c */ +#ifdef CONFIG_WATCHDOG_PRETIMEOUT_GOV +void watchdog_notify_pretimeout(struct watchdog_device *wdd); +#else +static inline void watchdog_notify_pretimeout(struct watchdog_device *wdd) {} +#endif + #endif /* ifndef _LINUX_WATCHDOG_H */

[1/7] watchdog: add watchdog pretimeout framework

Commit Message

Comments

Patch