watchdog: Replace driver based refcounting
Subsystems (5)
Guenter Roeck
maintainerv2 cover watchdog: Replace driver based refcounting
All variables required by the watchdog core to manage a watchdog are currently stored in struct watchdog_device. The lifetime of those variables is determined by the watchdog driver. However, the lifetime of variables used by the watchdog core differs from the lifetime of struct watchdog_device. To remedy this situation, watchdog drivers can implement ref and unref callbacks, to be used by the watchdog core to lock struct watchdog_device in memory. This mechanism was introduced with commit e907df327252 ("watchdog: Add support for dynamically allocated watchdog_device structs").
While this solves the immediate problem, it depends on watchdog drivers to actually implement the ref/unref callbacks. This is error prone, often not implemented in the first place, or not implemented correctly.
To solve the problem without requiring driver support, split the variables in struct watchdog_device into two data structures - one for variables associated with the watchdog driver, one for variables associated with the watchdog core. With this approach, the watchdog core can keep track of the variables it uses and no longer depends on ref/unref callbacks in the driver. As a side effect, some of the variables originally in struct watchdog_driver are now private to the watchdog core and no longer visible in watchdog drivers.
The 'ref' and 'unref' callbacks in struct watchdog_driver are no longer used and marked as deprecated for the time being.
Patch 1/6 moves watchdog device creation from watchdog_core.c to watchdog_dev.c to simplify watchdog device handling.
Patch 2/6 modifies the diag288 watchdog to no longer use and overload watchdog core internal flags.
Patch 3/6 separates variables in watchdog_device based on variable lifetime.
Patch 4/6 to 6/6 remove existing ref/unref functions from the drivers implementing it. Two of those patches (for da9052 and da9055) fix a previously introduced bug as side effect.
The series applies on top of the current watchdog-next as well as the pending patches introducing sysfs support ("watchdog: Use static struct class watchdog_class in stead of pointer" and "watchdog: Read device status through sysfs attributes") by Pratyush Anand.
---
v2: Add patch 2/6.
Add more detailed description to patch 3/6.
Rename internal data structure to watchdog_core_data, and the variable pointing to it to wd_data. Move its declaration into watchdog_dev.c. Reorder include files in watchdog_dev.c to alphabetic order. Remove _watchdog_ping helper function and call watchdog_ping() directly. Handle locks in the calling code.
Drop locking from watchdog_open(). It is already protected against parallel device removal in the driver core code, and file access functions won't be called before the function returns. Remove previously added message "watchdog still running". It wasn't there before, and we should avoid user visible changes. Add missing kfree() to the sch56xx patch.
Add comments to da9052 and da9055 patches indicating that the patches fix a bug.
Guenter Roeck
maintainerPATCH v2 1/6 watchdog: Create watchdog device in watchdog_dev.c
The watchdog character device is currently created in watchdog_dev.c, and the watchdog device in watchdog_core.c. This results in cross-dependencies, since device creation needs to know the watchdog character device number as well as the watchdog class, both of which reside in watchdog_dev.c.
Create the watchdog device in watchdog_dev.c to simplify the code.
Inspired by earlier patch set from Damien Riegel.
---
v2: No change
drivers/watchdog/watchdog_core.c | 33 ++++-------------- drivers/watchdog/watchdog_core.h | 4 +-- drivers/watchdog/watchdog_dev.c | 73 +++++++++++++++++++++++++++++++++------- 3 files changed, 69 insertions(+), 41 deletions(-)
drivers/watchdog/watchdog_core.c +7 -26
@@ -42,7 +42,6 @@#include "watchdog_core.h" /* For watchdog_dev_register/... */ static DEFINE_IDA (watchdog_ida); -static struct class *watchdog_class;/* * Deferred Registration infrastructure.
@@ -194,7 +193,7 @@ EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);static int __watchdog_register_device (struct watchdog_device *wdd) { -int ret, id =-1 , devno; +int ret, id =-1 ;if (wdd ==NULL || wdd->info ==NULL || wdd->ops ==NULL )return -EINVAL ;
@@ -247,16 +246,6 @@ static int __watchdog_register_device(struct watchdog_device *wdd) } } - devno = wdd->cdev.dev; - wdd->dev =device_create (watchdog_class, wdd->parent, devno, - wdd,"watchdog%d" , wdd->id); -if (IS_ERR (wdd->dev)) { -watchdog_dev_unregister (wdd); -ida_simple_remove (&watchdog_ida, id); - ret =PTR_ERR (wdd->dev); -return ret; - } -if (test_bit (WDOG_STOP_ON_REBOOT , &wdd->status)) { wdd->reboot_nb.notifier_call = watchdog_reboot_notifier;
@@ -265,9 +254,7 @@ static int __watchdog_register_device(struct watchdog_device *wdd)dev_err (wdd->dev,"Cannot register reboot notifier (%d)\n" , ret);watchdog_dev_unregister (wdd); -device_destroy (watchdog_class, devno);ida_simple_remove (&watchdog_ida, wdd->id); - wdd->dev =NULL ;return ret; } }
@@ -311,9 +298,6 @@ EXPORT_SYMBOL_GPL(watchdog_register_device);static void __watchdog_unregister_device (struct watchdog_device *wdd) { -int ret; -int devno; -if (wdd ==NULL )return ;
@@ -323,13 +307,8 @@ static void __watchdog_unregister_device(struct watchdog_device *wdd)if (test_bit (WDOG_STOP_ON_REBOOT , &wdd->status))unregister_reboot_notifier (&wdd->reboot_nb); - devno = wdd->cdev.dev; - ret =watchdog_dev_unregister (wdd); -if (ret) -pr_err ("error unregistering /dev/watchdog (err=%d)\n" , ret); -device_destroy (watchdog_class, devno); +watchdog_dev_unregister (wdd);ida_simple_remove (&watchdog_ida, wdd->id); - wdd->dev =NULL ; }/**
@@ -370,9 +349,11 @@ static int __init watchdog_deferred_registration(void)static int __init watchdog_init (void ) { - watchdog_class =watchdog_dev_init (); -if (IS_ERR (watchdog_class)) -return PTR_ERR (watchdog_class); +int err; + + err =watchdog_dev_init (); +if (err <0 ) +return err;watchdog_deferred_registration ();return 0 ;
drivers/watchdog/watchdog_core.h +2 -2
@@ -32,6 +32,6 @@* Functions/procedures to be called by the core */ extern int watchdog_dev_register (struct watchdog_device *); -extern int watchdog_dev_unregister (struct watchdog_device *); -extern struct class *__init watchdog_dev_init (void ); +extern void watchdog_dev_unregister (struct watchdog_device *); +extern int __init watchdog_dev_init (void ); extern void __exit watchdog_dev_exit(void);
drivers/watchdog/watchdog_dev.c +60 -13
133 lines not on this page · raw message
Signature · 1 line
2.1.4
Guenter Roeck
maintainerPATCH v2 2/6 watchdog: diag288: Stop re-using watchdog core internal flags
In reply to Guenter RoeckA watchdog driver should not use watchdog subsystem internal flags. Use a driver variable and flag instead to maintain the watchdog state and to determine if a suspend operation is possible or not.
---
v2: Added patch
drivers/watchdog/diag288_wdt.c | 26 ++++++++++++++++---------- 1 file changed, 16 insertions(+), 10 deletions(-)
drivers/watchdog/diag288_wdt.c +16 -10
@@ -106,6 +106,10 @@ static int __diag288_lpar(unsigned int func, unsigned int timeout,return __diag288 (func, timeout, action,0 ); } +static unsigned long wdt_status; + +#define DIAG_WDOG_BUSY 0 +static int wdt_start (struct watchdog_device *dev) {char *ebc_cmd;
@@ -113,12 +117,17 @@ static int wdt_start(struct watchdog_device *dev)int ret;unsigned int func; +if (test_and_set_bit (DIAG_WDOG_BUSY , &wdt_status)) +return -EBUSY ; + ret = -ENODEV ;if (MACHINE_IS_VM ) { ebc_cmd =kmalloc (MAX_CMDLEN ,GFP_KERNEL ); -if (!ebc_cmd) +if (!ebc_cmd) { +clear_bit (DIAG_WDOG_BUSY , &wdt_status);return -ENOMEM ; + } len =strlcpy (ebc_cmd, wdt_cmd,MAX_CMDLEN );ASCEBC (ebc_cmd,MAX_CMDLEN );EBC_TOUPPER (ebc_cmd,MAX_CMDLEN );
@@ -135,6 +144,7 @@ static int wdt_start(struct watchdog_device *dev)if (ret) {pr_err ("The watchdog cannot be activated\n" ); +clear_bit (DIAG_WDOG_BUSY , &wdt_status);return ret; }return 0 ;
@@ -146,6 +156,9 @@ static int wdt_stop(struct watchdog_device *dev)diag_stat_inc (DIAG_STAT_X288 ); ret =__diag288 (WDT_FUNC_CANCEL ,0 ,0 ,0 ); + +clear_bit (DIAG_WDOG_BUSY , &wdt_status); +return ret; }
@@ -220,17 +233,10 @@ static struct watchdog_device wdt_dev = {* It makes no sense to go into suspend while the watchdog is running. * Depending on the memory size, the watchdog might trigger, while we * are still saving the memory. -* We reuse the open flag to ensure that suspend and watchdog open are -* exclusive operations */ static int wdt_suspend (void ) { -if (test_and_set_bit (WDOG_DEV_OPEN , &wdt_dev.status)) { -pr_err ("Linux cannot be suspended while the watchdog is in use\n" ); -return notifier_from_errno (-EBUSY ); - } -if (test_bit (WDOG_ACTIVE , &wdt_dev.status)) { -clear_bit (WDOG_DEV_OPEN , &wdt_dev.status); +if (test_and_set_bit (DIAG_WDOG_BUSY , &wdt_status)) {pr_err ("Linux cannot be suspended while the watchdog is in use\n" );return notifier_from_errno (-EBUSY ); }
@@ -239,7 +245,7 @@ static int wdt_suspend(void)static int wdt_resume (void ) { -clear_bit (WDOG_DEV_OPEN , &wdt_dev.status); +clear_bit (DIAG_WDOG_BUSY , &wdt_status);return NOTIFY_DONE ; }
Signature · 1 line
2.1.4
Guenter Roeck
maintainerPATCH v2 3/6 watchdog: Separate and maintain variables based on variable lifetime
In reply to Guenter RoeckAll variables required by the watchdog core to manage a watchdog are currently stored in struct watchdog_device. The lifetime of those variables is determined by the watchdog driver. However, the lifetime of variables used by the watchdog core differs from the lifetime of struct watchdog_device. To remedy this situation, watchdog drivers can implement ref and unref callbacks, to be used by the watchdog core to lock struct watchdog_device in memory.
While this solves the immediate problem, it depends on watchdog drivers to actually implement the ref/unref callbacks. This is error prone, often not implemented in the first place, or not implemented correctly.
To solve the problem without requiring driver support, split the variables in struct watchdog_device into two data structures - one for variables associated with the watchdog driver, one for variables associated with the watchdog core. With this approach, the watchdog core can keep track of its variable lifetime and no longer depends on ref/unref callbacks in the driver. As a side effect, some of the variables originally in struct watchdog_driver are now private to the watchdog core and no longer visible in watchdog drivers.
As a side effect of the changes made, an ioctl will now always fail with -ENODEV after a watchdog device was unregistered with the character device still open. Previously, it would only fail with -ENODEV in some situations. Also, ioctl operations are now atomic from driver perspective. With this change, it is now guaranteed that the driver will not unregister a watchdog between a timeout change and the subsequent ping.
The 'ref' and 'unref' callbacks in struct watchdog_driver are no longer used and marked as deprecated.
---
v2: More detailed description
Rename internal data structure to watchdog_core_data, and the variable pointing to it to wd_data. Move its declaration into watchdog_dev.c. Reorder include files in watchdog_dev.c to alphabetic order. Remove _watchdog_ping helper function and call watchdog_ping() directly. Handle locks in the calling code.
Drop locking from watchdog_open(). It is already protected against parallel device removal in the driver core code, and file access functions won't be called before the function returns. Remove previously added message "watchdog still running". It wasn't there before, and we should avoid user visible changes.
Documentation/watchdog/watchdog-kernel-api.txt | 45 +-- drivers/watchdog/watchdog_core.c | 2 - drivers/watchdog/watchdog_dev.c | 383 +++++++++++++------------ include/linux/watchdog.h | 22 +- 4 files changed, 218 insertions(+), 234 deletions(-)
Documentation/watchdog/watchdog-kernel-api.txt +7 -38
@@ -44,7 +44,6 @@ The watchdog device structure looks like this: struct watchdog_device { int id; - struct cdev cdev; struct device *dev; struct device *parent; const struct watchdog_info *info;
@@ -56,7 +55,7 @@ struct watchdog_device { struct notifier_block reboot_nb; struct notifier_block restart_nb; void *driver_data; - struct mutex lock; + struct watchdog_core_data *wd_data; unsigned long status; struct list_head deferred; };
@@ -66,8 +65,6 @@ It contains following fields: /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. -* cdev: cdev for the dynamic /dev/watchdog<id> device nodes. This - field is also populated by watchdog_register_device. * dev: device under the watchdog class (created by watchdog_register_device). * parent: set this to the parent device (or NULL) before calling watchdog_register_device.
@@ -89,11 +86,10 @@ It contains following fields: * 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. -* lock: Mutex for WatchDog Timer Driver Core internal use only. +* 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, is the nowayout bit set, is the device opened via - the /dev/watchdog interface or not, ...). + running/active, or is the nowayout bit set). * deferred: entry in wtd_deferred_reg_list which is used to register early initialized watchdogs.
@@ -110,8 +106,8 @@ struct watchdog_ops { int (*set_timeout)(struct watchdog_device *, unsigned int); unsigned int (*get_timeleft)(struct watchdog_device *); int (*restart)(struct watchdog_device *); - void (*ref)(struct watchdog_device *); - void (*unref)(struct watchdog_device *); + void (*ref)(struct watchdog_device *) __deprecated; + void (*unref)(struct watchdog_device *) __deprecated; long (*ioctl)(struct watchdog_device *, unsigned int, unsigned long); };
@@ -120,20 +116,6 @@ 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). -If the watchdog_device struct is dynamically allocated, just locking the module -is not enough and a driver also needs to define the ref and unref operations to -ensure the structure holding the watchdog_device does not go away. - -The simplest (and usually sufficient) implementation of this is to: -1) Add a kref struct to the same structure which is holding the watchdog_device -2) Define a release callback for the kref which frees the struct holding both -3) Call kref_init on this kref *before* calling watchdog_register_device() -4) Define a ref operation calling kref_get on this kref -5) Define a unref operation calling kref_put on this kref -6) When it is time to cleanup: - * Do not kfree() the struct holding both, the last kref_put will do this! - * *After* calling watchdog_unregister_device() call kref_put on the kref - 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
@@ -176,34 +158,21 @@ they are supported. These optional routines/operations are: * 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. -* ref: the operation that calls kref_get on the kref of a dynamically - allocated watchdog_device struct. -* unref: the operation that calls kref_put on the kref of a dynamically - allocated watchdog_device struct. * 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. When the watchdog is active after booting, then you should set this status bit (Note: when you register the watchdog timer device with this bit set, then opening /dev/watchdog will skip the start operation) -* WDOG_DEV_OPEN: this status bit shows whether or not the watchdog device - was opened via /dev/watchdog. - (This bit should only be used by the WatchDog Timer Driver Core). -* WDOG_ALLOW_RELEASE: this bit stores whether or not the magic close character - has been sent (so that we can support the magic close feature). - (This bit should only be used by the WatchDog Timer Driver Core). * 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_UNREGISTERED: this bit gets set by the WatchDog Timer Driver Core - after calling watchdog_unregister_device, and then checked before calling - any watchdog_ops, so that you can be sure that no operations (other then - unref) will get called after unregister, even if userspace still holds a - reference to /dev/watchdog To set the WDOG_NO_WAY_OUT status bit (before registering your watchdog timer device) you can either:
drivers/watchdog/watchdog_core.c +0 -2
@@ -210,8 +210,6 @@ static int __watchdog_register_device(struct watchdog_device *wdd)* corrupted in a later stage then we expect a kernel panic! */ -mutex_init (&wdd->lock); -/* Use alias for watchdog id if possible */ if (wdd->parent) { ret =of_alias_get_id (wdd->parent->of_node,"watchdog" );
drivers/watchdog/watchdog_dev.c +203 -180
705 lines not on this page · raw message
include/linux/watchdog.h +8 -14
@@ -17,6 +17,7 @@struct watchdog_ops ;struct watchdog_device ; +struct watchdog_core_data ;/** struct watchdog_ops - The watchdog-devices operations *
@@ -28,8 +29,6 @@ struct watchdog_device;* @set_timeout:The routine for setting the watchdog devices timeout value (in seconds). * @get_timeleft:The routine that gets the time left before a reset (in seconds). * @restart: The routine for restarting the machine. -* @ref: The ref operation for dyn. allocated watchdog_device structs -* @unref: The unref operation for dyn. allocated watchdog_device structs * @ioctl: The routines that handles extra ioctl calls. * * The watchdog_ops structure contains a list of low-level operations
@@ -48,15 +47,14 @@ struct watchdog_ops {int (*set_timeout)(struct watchdog_device *,unsigned int );unsigned int (*get_timeleft)(struct watchdog_device *);int (*restart)(struct watchdog_device *); -void (*ref)(struct watchdog_device *); -void (*unref)(struct watchdog_device *); +void (*ref)(struct watchdog_device *)__deprecated ; +void (*unref)(struct watchdog_device *)__deprecated ;long (*ioctl)(struct watchdog_device *,unsigned int ,unsigned long ); };/** struct watchdog_device - The structure that defines a watchdog device * * @id: The watchdog's ID. (Allocated by watchdog_register_device) -* @cdev: The watchdog's Character device. * @dev: The device for our watchdog * @parent: The parent bus device * @info: Pointer to a watchdog_info structure.
@@ -67,8 +65,8 @@ struct watchdog_ops {* @max_timeout:The watchdog devices maximum timeout value (in seconds). * @reboot_nb: The notifier block to stop watchdog on reboot. * @restart_nb: The notifier block to register a restart function. -* @driver-data:Pointer to the drivers private data. -* @lock: Lock for watchdog core internal use only. +* @driver_data:Pointer to the drivers private data. +* @wd_data: Pointer to watchdog core internal data. * @status: Field that contains the devices internal status bits. * @deferred: entry in wtd_deferred_reg_list which is used to * register early initialized watchdogs.
@@ -84,7 +82,6 @@ struct watchdog_ops {*/ struct watchdog_device {int id; -struct cdev cdev;struct device *dev;struct device *parent;const struct watchdog_info *info;
@@ -96,15 +93,12 @@ struct watchdog_device {struct notifier_block reboot_nb;struct notifier_block restart_nb;void *driver_data; -struct mutex lock; +struct watchdog_core_data *wd_data;unsigned long status;/* Bit numbers for status flags */ #define WDOG_ACTIVE 0/* Is the watchdog running/active */ -#define WDOG_DEV_OPEN 1/* Opened via /dev/watchdog ? */ -#define WDOG_ALLOW_RELEASE 2/* Did we receive the magic char ? */ -#define WDOG_NO_WAY_OUT 3/* Is 'nowayout' feature set ? */ -#define WDOG_UNREGISTERED 4/* Has the device been unregistered */ -#define WDOG_STOP_ON_REBOOT 5/* Should be stopped on reboot */ +#define WDOG_NO_WAY_OUT 1/* Is 'nowayout' feature set ? */ +#define WDOG_STOP_ON_REBOOT 2/* Should be stopped on reboot */ struct list_head deferred; };
Signature · 1 line
2.1.4
Guenter Roeck
maintainerPATCH v2 4/6 watchdog: da9052_wdt: Drop reference counting
In reply to Guenter RoeckReference counting is now implemented in the watchdog core and no longer required in watchdog drivers.
Since it was implememented a no-op, and since the local memory is allocated with devm_kzalloc(), the reference counting code in the driver really did not really work anyway, and this patch effectively fixes a bug which could cause a crash on unloading if the watchdog device was still open.
---
v4: Add note that this patch also fixes a bug.
drivers/watchdog/da9052_wdt.c | 24 ------------------------ 1 file changed, 24 deletions(-)
drivers/watchdog/da9052_wdt.c +0 -24
@@ -31,7 +31,6 @@struct da9052_wdt_data {struct watchdog_device wdt;struct da9052 *da9052; -struct kref kref;unsigned long jpast; };
@@ -51,10 +50,6 @@ static const struct { }; -static void da9052_wdt_release_resources (struct kref *r) -{ -} -static int da9052_wdt_set_timeout (struct watchdog_device *wdt_dev,unsigned int timeout) {
@@ -104,20 +99,6 @@ static int da9052_wdt_set_timeout(struct watchdog_device *wdt_dev,return 0 ; } -static void da9052_wdt_ref (struct watchdog_device *wdt_dev) -{ -struct da9052_wdt_data *driver_data =watchdog_get_drvdata (wdt_dev); - -kref_get (&driver_data->kref); -} - -static void da9052_wdt_unref (struct watchdog_device *wdt_dev) -{ -struct da9052_wdt_data *driver_data =watchdog_get_drvdata (wdt_dev); - -kref_put (&driver_data->kref, da9052_wdt_release_resources); -} -static int da9052_wdt_start (struct watchdog_device *wdt_dev) {return da9052_wdt_set_timeout (wdt_dev, wdt_dev->timeout);
@@ -170,8 +151,6 @@ static const struct watchdog_ops da9052_wdt_ops = { .stop = da9052_wdt_stop, .ping = da9052_wdt_ping, .set_timeout = da9052_wdt_set_timeout, - .ref = da9052_wdt_ref, - .unref = da9052_wdt_unref, };
@@ -198,8 +177,6 @@ static int da9052_wdt_probe(struct platform_device *pdev) da9052_wdt->parent = &pdev->dev;watchdog_set_drvdata (da9052_wdt, driver_data); -kref_init (&driver_data->kref); - ret =da9052_reg_update (da9052,DA9052_CONTROL_D_REG ,DA9052_CONTROLD_TWDSCALE ,0 );if (ret <0 ) {
@@ -225,7 +202,6 @@ static int da9052_wdt_remove(struct platform_device *pdev)struct da9052_wdt_data *driver_data =platform_get_drvdata (pdev);watchdog_unregister_device (&driver_data->wdt); -kref_put (&driver_data->kref, da9052_wdt_release_resources);return 0 ; }
Signature · 1 line
2.1.4
Guenter Roeck
maintainerPATCH v2 5/6 watchdog: da9055_wdt: Drop reference counting
In reply to Guenter RoeckReference counting is now implemented in the watchdog core and no longer required in watchdog drivers.
Since it was implememented a no-op, and since the local memory is allocated with devm_kzalloc(), the reference counting code in the driver really did not really work anyway, and this patch effectively fixes a bug which could cause a crash on unloading if the watchdog device was still open.
---
v2: Add note that the patch also fixes a bug.
drivers/watchdog/da9055_wdt.c | 24 ------------------------ 1 file changed, 24 deletions(-)
drivers/watchdog/da9055_wdt.c +0 -24
@@ -35,7 +35,6 @@ MODULE_PARM_DESC(nowayout,struct da9055_wdt_data {struct watchdog_device wdt;struct da9055 *da9055; -struct kref kref; }; static const struct {
@@ -99,24 +98,6 @@ static int da9055_wdt_ping(struct watchdog_device *wdt_dev) DA9055_WATCHDOG_MASK, 1); } -static void da9055_wdt_release_resources (struct kref *r) -{ -} - -static void da9055_wdt_ref (struct watchdog_device *wdt_dev) -{ -struct da9055_wdt_data *driver_data =watchdog_get_drvdata (wdt_dev); - -kref_get (&driver_data->kref); -} - -static void da9055_wdt_unref (struct watchdog_device *wdt_dev) -{ -struct da9055_wdt_data *driver_data =watchdog_get_drvdata (wdt_dev); - -kref_put (&driver_data->kref, da9055_wdt_release_resources); -} -static int da9055_wdt_start (struct watchdog_device *wdt_dev) {return da9055_wdt_set_timeout (wdt_dev, wdt_dev->timeout);
@@ -138,8 +119,6 @@ static const struct watchdog_ops da9055_wdt_ops = { .stop = da9055_wdt_stop, .ping = da9055_wdt_ping, .set_timeout = da9055_wdt_set_timeout, - .ref = da9055_wdt_ref, - .unref = da9055_wdt_unref, };static int da9055_wdt_probe (struct platform_device *pdev)
@@ -165,8 +144,6 @@ static int da9055_wdt_probe(struct platform_device *pdev)watchdog_set_nowayout (da9055_wdt, nowayout);watchdog_set_drvdata (da9055_wdt, driver_data); -kref_init (&driver_data->kref); - ret =da9055_wdt_stop (da9055_wdt);if (ret <0 ) {dev_err (&pdev->dev,"Failed to stop watchdog, %d\n" , ret);
@@ -189,7 +166,6 @@ static int da9055_wdt_remove(struct platform_device *pdev)struct da9055_wdt_data *driver_data =platform_get_drvdata (pdev);watchdog_unregister_device (&driver_data->wdt); -kref_put (&driver_data->kref, da9055_wdt_release_resources);return 0 ; }
Signature · 1 line
2.1.4
Guenter Roeck
maintainerPATCH v2 6/6 hwmon: (sch56xx) Drop watchdog driver data reference count callbacks
In reply to Guenter RoeckReference counting is now implemented in the watchdog core and no longer required in watchdog drivers.
---
v2: Add missing kfree().
drivers/hwmon/sch56xx-common.c | 31 +------------------------------ 1 file changed, 1 insertion(+), 30 deletions(-)
drivers/hwmon/sch56xx-common.c +1 -30
@@ -30,7 +30,6 @@#include <linux/watchdog.h> #include <linux/miscdevice.h> #include <linux/uaccess.h> -#include <linux/kref.h> #include <linux/slab.h> #include "sch56xx-common.h"
@@ -67,7 +66,6 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="struct sch56xx_watchdog_data {u16 addr;struct mutex *io_lock; -struct kref kref;struct watchdog_info wdinfo;struct watchdog_device wddev;u8 watchdog_preset;
@@ -258,15 +256,6 @@ EXPORT_SYMBOL(sch56xx_read_virtual_reg12);* Watchdog routines */ -/* Release our data struct when we're unregistered *and* -all references to our watchdog device are released */ -static void watchdog_release_resources (struct kref *r) -{ -struct sch56xx_watchdog_data *data = - container_of(r, struct sch56xx_watchdog_data, kref); -kfree (data); -} -static int watchdog_set_timeout (struct watchdog_device *wddev,unsigned int timeout) {
@@ -395,28 +384,12 @@ static int watchdog_stop(struct watchdog_device *wddev)return 0 ; } -static void watchdog_ref (struct watchdog_device *wddev) -{ -struct sch56xx_watchdog_data *data =watchdog_get_drvdata (wddev); - -kref_get (&data->kref); -} - -static void watchdog_unref (struct watchdog_device *wddev) -{ -struct sch56xx_watchdog_data *data =watchdog_get_drvdata (wddev); - -kref_put (&data->kref, watchdog_release_resources); -} -static const struct watchdog_ops watchdog_ops = { .owner =THIS_MODULE , .start = watchdog_start, .stop = watchdog_stop, .ping = watchdog_trigger, .set_timeout = watchdog_set_timeout, - .ref = watchdog_ref, - .unref = watchdog_unref, }; struct sch56xx_watchdog_data *sch56xx_watchdog_register(struct device *parent,
@@ -448,7 +421,6 @@ struct sch56xx_watchdog_data *sch56xx_watchdog_register(struct device *parent, data->addr = addr; data->io_lock = io_lock; -kref_init (&data->kref);strlcpy (data->wdinfo.identity,"sch56xx watchdog" ,sizeof (data->wdinfo.identity));
@@ -494,8 +466,7 @@ EXPORT_SYMBOL(sch56xx_watchdog_register);void sch56xx_watchdog_unregister (struct sch56xx_watchdog_data *data) {watchdog_unregister_device (&data->wddev); -kref_put (&data->kref, watchdog_release_resources); -/* Don't touch data after this it may have been free-ed! */ +kfree (data); }EXPORT_SYMBOL (sch56xx_watchdog_unregister);
Signature · 1 line
2.1.4
Hi Guenter,
Quoted 44 lines
All variables required by the watchdog core to manage a watchdog are currently stored in struct
watchdog_device. The lifetime of those variables is determined by the watchdog driver. However, the lifetime of variables used by the watchdog core differs from the lifetime of structwatchdog_device. To remedy this situation, watchdog drivers can implement ref and unref callbacks, to be used by the watchdog core to lock structwatchdog_devicein memory. This mechanism was introduced with commite907df327252("watchdog: Add support for dynamically allocatedwatchdog_devicestructs").While this solves the immediate problem, it depends on watchdog drivers to actually implement the ref/unref callbacks. This is error prone, often not implemented in the first place, or not implemented correctly.
To solve the problem without requiring driver support, split the variables in struct
watchdog_deviceinto two data structures - one for variables associated with the watchdog driver, one for variables associated with the watchdog core. With this approach, the watchdog core can keep track of the variables it uses and no longer depends on ref/unref callbacks in the driver. As a side effect, some of the variables originally in structwatchdog_driverare now private to the watchdog core and no longer visible in watchdog drivers.The 'ref' and 'unref' callbacks in struct
watchdog_driverare no longer used and marked as deprecated for the time being.Patch 1/6 moves watchdog device creation from
watchdog_core.ctowatchdog_dev.cto simplify watchdog device handling.Patch 2/6 modifies the diag288 watchdog to no longer use and overload watchdog core internal flags.
Patch 3/6 separates variables in
watchdog_devicebased on variable lifetime.Patch 4/6 to 6/6 remove existing ref/unref functions from the drivers implementing it. Two of those patches (for da9052 and da9055) fix a previously introduced bug as side effect.
The series applies on top of the current watchdog-next as well as the pending patches introducing sysfs support ("watchdog: Use static struct class
watchdog_classin stead of pointer" and "watchdog: Read device status through sysfs attributes") by Pratyush Anand.
Quoted 16 lines
---
v2: Add patch 2/6.
Add more detailed description to patch 3/6.
Rename internal data structure towatchdog_core_data, and the variable pointing to it towd_data. Move its declaration intowatchdog_dev.c. Reorder include files inwatchdog_dev.cto alphabetic order. Remove_watchdog_pinghelper function and callwatchdog_ping()directly. Handle locks in the calling code.
Drop locking fromwatchdog_open(). It is already protected against parallel device removal in the driver core code, and file access functions won't be called before the function returns. Remove previously added message "watchdog still running". It wasn't there before, and we should avoid user visible changes. Add missingkfree()to the sch56xx patch.
Add comments to da9052 and da9055 patches indicating that the patches fix a bug.
This patchset has been added to linux-watchdog-next.
Kind regards,
Wim.