LCOV - code coverage report
Current view: top level - drivers/watchdog - watchdog_dev.c (source / functions) Hit Total Coverage
Test: Real Lines: 45 311 14.5 %
Date: 2020-10-17 15:46:16 Functions: 0 26 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0+
       2                 :            : /*
       3                 :            :  *      watchdog_dev.c
       4                 :            :  *
       5                 :            :  *      (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
       6                 :            :  *                                              All Rights Reserved.
       7                 :            :  *
       8                 :            :  *      (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
       9                 :            :  *
      10                 :            :  *
      11                 :            :  *      This source code is part of the generic code that can be used
      12                 :            :  *      by all the watchdog timer drivers.
      13                 :            :  *
      14                 :            :  *      This part of the generic code takes care of the following
      15                 :            :  *      misc device: /dev/watchdog.
      16                 :            :  *
      17                 :            :  *      Based on source code of the following authors:
      18                 :            :  *        Matt Domsch <Matt_Domsch@dell.com>,
      19                 :            :  *        Rob Radez <rob@osinvestor.com>,
      20                 :            :  *        Rusty Lynch <rusty@linux.co.intel.com>
      21                 :            :  *        Satyam Sharma <satyam@infradead.org>
      22                 :            :  *        Randy Dunlap <randy.dunlap@oracle.com>
      23                 :            :  *
      24                 :            :  *      Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
      25                 :            :  *      admit liability nor provide warranty for any of this software.
      26                 :            :  *      This material is provided "AS-IS" and at no charge.
      27                 :            :  */
      28                 :            : 
      29                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      30                 :            : 
      31                 :            : #include <linux/cdev.h>           /* For character device */
      32                 :            : #include <linux/errno.h>  /* For the -ENODEV/... values */
      33                 :            : #include <linux/fs.h>             /* For file operations */
      34                 :            : #include <linux/init.h>           /* For __init/__exit/... */
      35                 :            : #include <linux/hrtimer.h>        /* For hrtimers */
      36                 :            : #include <linux/kernel.h> /* For printk/panic/... */
      37                 :            : #include <linux/kthread.h>        /* For kthread_work */
      38                 :            : #include <linux/miscdevice.h>     /* For handling misc devices */
      39                 :            : #include <linux/module.h> /* For module stuff/... */
      40                 :            : #include <linux/mutex.h>  /* For mutexes */
      41                 :            : #include <linux/slab.h>           /* For memory functions */
      42                 :            : #include <linux/types.h>  /* For standard types (like size_t) */
      43                 :            : #include <linux/watchdog.h>       /* For watchdog specific items */
      44                 :            : #include <linux/uaccess.h>        /* For copy_to_user/put_user/... */
      45                 :            : 
      46                 :            : #include <uapi/linux/sched/types.h>       /* For struct sched_param */
      47                 :            : 
      48                 :            : #include "watchdog_core.h"
      49                 :            : #include "watchdog_pretimeout.h"
      50                 :            : 
      51                 :            : /*
      52                 :            :  * struct watchdog_core_data - watchdog core internal data
      53                 :            :  * @dev:        The watchdog's internal device
      54                 :            :  * @cdev:       The watchdog's Character device.
      55                 :            :  * @wdd:        Pointer to watchdog device.
      56                 :            :  * @lock:       Lock for watchdog core.
      57                 :            :  * @status:     Watchdog core internal status bits.
      58                 :            :  */
      59                 :            : struct watchdog_core_data {
      60                 :            :         struct device dev;
      61                 :            :         struct cdev cdev;
      62                 :            :         struct watchdog_device *wdd;
      63                 :            :         struct mutex lock;
      64                 :            :         ktime_t last_keepalive;
      65                 :            :         ktime_t last_hw_keepalive;
      66                 :            :         ktime_t open_deadline;
      67                 :            :         struct hrtimer timer;
      68                 :            :         struct kthread_work work;
      69                 :            :         unsigned long status;           /* Internal status bits */
      70                 :            : #define _WDOG_DEV_OPEN          0       /* Opened ? */
      71                 :            : #define _WDOG_ALLOW_RELEASE     1       /* Did we receive the magic char ? */
      72                 :            : #define _WDOG_KEEPALIVE         2       /* Did we receive a keepalive ? */
      73                 :            : };
      74                 :            : 
      75                 :            : /* the dev_t structure to store the dynamically allocated watchdog devices */
      76                 :            : static dev_t watchdog_devt;
      77                 :            : /* Reference to watchdog device behind /dev/watchdog */
      78                 :            : static struct watchdog_core_data *old_wd_data;
      79                 :            : 
      80                 :            : static struct kthread_worker *watchdog_kworker;
      81                 :            : 
      82                 :            : static bool handle_boot_enabled =
      83                 :            :         IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED);
      84                 :            : 
      85                 :            : static unsigned open_timeout = CONFIG_WATCHDOG_OPEN_TIMEOUT;
      86                 :            : 
      87                 :          0 : static bool watchdog_past_open_deadline(struct watchdog_core_data *data)
      88                 :            : {
      89                 :          0 :         return ktime_after(ktime_get(), data->open_deadline);
      90                 :            : }
      91                 :            : 
      92                 :          3 : static void watchdog_set_open_deadline(struct watchdog_core_data *data)
      93                 :            : {
      94                 :          3 :         data->open_deadline = open_timeout ?
      95                 :          3 :                 ktime_get() + ktime_set(open_timeout, 0) : KTIME_MAX;
      96                 :          3 : }
      97                 :            : 
      98                 :          0 : static inline bool watchdog_need_worker(struct watchdog_device *wdd)
      99                 :            : {
     100                 :            :         /* All variables in milli-seconds */
     101                 :          0 :         unsigned int hm = wdd->max_hw_heartbeat_ms;
     102                 :          0 :         unsigned int t = wdd->timeout * 1000;
     103                 :            : 
     104                 :            :         /*
     105                 :            :          * A worker to generate heartbeat requests is needed if all of the
     106                 :            :          * following conditions are true.
     107                 :            :          * - Userspace activated the watchdog.
     108                 :            :          * - The driver provided a value for the maximum hardware timeout, and
     109                 :            :          *   thus is aware that the framework supports generating heartbeat
     110                 :            :          *   requests.
     111                 :            :          * - Userspace requests a longer timeout than the hardware can handle.
     112                 :            :          *
     113                 :            :          * Alternatively, if userspace has not opened the watchdog
     114                 :            :          * device, we take care of feeding the watchdog if it is
     115                 :            :          * running.
     116                 :            :          */
     117                 :          0 :         return (hm && watchdog_active(wdd) && t > hm) ||
     118                 :          0 :                 (t && !watchdog_active(wdd) && watchdog_hw_running(wdd));
     119                 :            : }
     120                 :            : 
     121                 :          0 : static ktime_t watchdog_next_keepalive(struct watchdog_device *wdd)
     122                 :            : {
     123                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     124                 :          0 :         unsigned int timeout_ms = wdd->timeout * 1000;
     125                 :            :         ktime_t keepalive_interval;
     126                 :            :         ktime_t last_heartbeat, latest_heartbeat;
     127                 :            :         ktime_t virt_timeout;
     128                 :            :         unsigned int hw_heartbeat_ms;
     129                 :            : 
     130                 :          0 :         if (watchdog_active(wdd))
     131                 :          0 :                 virt_timeout = ktime_add(wd_data->last_keepalive,
     132                 :            :                                          ms_to_ktime(timeout_ms));
     133                 :            :         else
     134                 :          0 :                 virt_timeout = wd_data->open_deadline;
     135                 :            : 
     136                 :          0 :         hw_heartbeat_ms = min_not_zero(timeout_ms, wdd->max_hw_heartbeat_ms);
     137                 :          0 :         keepalive_interval = ms_to_ktime(hw_heartbeat_ms / 2);
     138                 :            : 
     139                 :            :         /*
     140                 :            :          * To ensure that the watchdog times out wdd->timeout seconds
     141                 :            :          * after the most recent ping from userspace, the last
     142                 :            :          * worker ping has to come in hw_heartbeat_ms before this timeout.
     143                 :            :          */
     144                 :          0 :         last_heartbeat = ktime_sub(virt_timeout, ms_to_ktime(hw_heartbeat_ms));
     145                 :          0 :         latest_heartbeat = ktime_sub(last_heartbeat, ktime_get());
     146                 :          0 :         if (ktime_before(latest_heartbeat, keepalive_interval))
     147                 :            :                 return latest_heartbeat;
     148                 :          0 :         return keepalive_interval;
     149                 :            : }
     150                 :            : 
     151                 :          0 : static inline void watchdog_update_worker(struct watchdog_device *wdd)
     152                 :            : {
     153                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     154                 :            : 
     155                 :          0 :         if (watchdog_need_worker(wdd)) {
     156                 :          0 :                 ktime_t t = watchdog_next_keepalive(wdd);
     157                 :            : 
     158                 :          0 :                 if (t > 0)
     159                 :          0 :                         hrtimer_start(&wd_data->timer, t,
     160                 :            :                                       HRTIMER_MODE_REL_HARD);
     161                 :            :         } else {
     162                 :          0 :                 hrtimer_cancel(&wd_data->timer);
     163                 :            :         }
     164                 :          0 : }
     165                 :            : 
     166                 :          0 : static int __watchdog_ping(struct watchdog_device *wdd)
     167                 :            : {
     168                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     169                 :            :         ktime_t earliest_keepalive, now;
     170                 :            :         int err;
     171                 :            : 
     172                 :          0 :         earliest_keepalive = ktime_add(wd_data->last_hw_keepalive,
     173                 :            :                                        ms_to_ktime(wdd->min_hw_heartbeat_ms));
     174                 :          0 :         now = ktime_get();
     175                 :            : 
     176                 :          0 :         if (ktime_after(earliest_keepalive, now)) {
     177                 :          0 :                 hrtimer_start(&wd_data->timer,
     178                 :            :                               ktime_sub(earliest_keepalive, now),
     179                 :            :                               HRTIMER_MODE_REL_HARD);
     180                 :          0 :                 return 0;
     181                 :            :         }
     182                 :            : 
     183                 :          0 :         wd_data->last_hw_keepalive = now;
     184                 :            : 
     185                 :          0 :         if (wdd->ops->ping)
     186                 :          0 :                 err = wdd->ops->ping(wdd);  /* ping the watchdog */
     187                 :            :         else
     188                 :          0 :                 err = wdd->ops->start(wdd); /* restart watchdog */
     189                 :            : 
     190                 :          0 :         watchdog_update_worker(wdd);
     191                 :            : 
     192                 :          0 :         return err;
     193                 :            : }
     194                 :            : 
     195                 :            : /*
     196                 :            :  *      watchdog_ping: ping the watchdog.
     197                 :            :  *      @wdd: the watchdog device to ping
     198                 :            :  *
     199                 :            :  *      The caller must hold wd_data->lock.
     200                 :            :  *
     201                 :            :  *      If the watchdog has no own ping operation then it needs to be
     202                 :            :  *      restarted via the start operation. This wrapper function does
     203                 :            :  *      exactly that.
     204                 :            :  *      We only ping when the watchdog device is running.
     205                 :            :  */
     206                 :            : 
     207                 :          0 : static int watchdog_ping(struct watchdog_device *wdd)
     208                 :            : {
     209                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     210                 :            : 
     211                 :          0 :         if (!watchdog_active(wdd) && !watchdog_hw_running(wdd))
     212                 :            :                 return 0;
     213                 :            : 
     214                 :          0 :         set_bit(_WDOG_KEEPALIVE, &wd_data->status);
     215                 :            : 
     216                 :          0 :         wd_data->last_keepalive = ktime_get();
     217                 :          0 :         return __watchdog_ping(wdd);
     218                 :            : }
     219                 :            : 
     220                 :          0 : static bool watchdog_worker_should_ping(struct watchdog_core_data *wd_data)
     221                 :            : {
     222                 :          0 :         struct watchdog_device *wdd = wd_data->wdd;
     223                 :            : 
     224                 :          0 :         if (!wdd)
     225                 :            :                 return false;
     226                 :            : 
     227                 :          0 :         if (watchdog_active(wdd))
     228                 :            :                 return true;
     229                 :            : 
     230                 :          0 :         return watchdog_hw_running(wdd) && !watchdog_past_open_deadline(wd_data);
     231                 :            : }
     232                 :            : 
     233                 :          0 : static void watchdog_ping_work(struct kthread_work *work)
     234                 :            : {
     235                 :            :         struct watchdog_core_data *wd_data;
     236                 :            : 
     237                 :          0 :         wd_data = container_of(work, struct watchdog_core_data, work);
     238                 :            : 
     239                 :          0 :         mutex_lock(&wd_data->lock);
     240                 :          0 :         if (watchdog_worker_should_ping(wd_data))
     241                 :          0 :                 __watchdog_ping(wd_data->wdd);
     242                 :          0 :         mutex_unlock(&wd_data->lock);
     243                 :          0 : }
     244                 :            : 
     245                 :          0 : static enum hrtimer_restart watchdog_timer_expired(struct hrtimer *timer)
     246                 :            : {
     247                 :            :         struct watchdog_core_data *wd_data;
     248                 :            : 
     249                 :            :         wd_data = container_of(timer, struct watchdog_core_data, timer);
     250                 :            : 
     251                 :          0 :         kthread_queue_work(watchdog_kworker, &wd_data->work);
     252                 :          0 :         return HRTIMER_NORESTART;
     253                 :            : }
     254                 :            : 
     255                 :            : /*
     256                 :            :  *      watchdog_start: wrapper to start the watchdog.
     257                 :            :  *      @wdd: the watchdog device to start
     258                 :            :  *
     259                 :            :  *      The caller must hold wd_data->lock.
     260                 :            :  *
     261                 :            :  *      Start the watchdog if it is not active and mark it active.
     262                 :            :  *      This function returns zero on success or a negative errno code for
     263                 :            :  *      failure.
     264                 :            :  */
     265                 :            : 
     266                 :          0 : static int watchdog_start(struct watchdog_device *wdd)
     267                 :            : {
     268                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     269                 :            :         ktime_t started_at;
     270                 :            :         int err;
     271                 :            : 
     272                 :          0 :         if (watchdog_active(wdd))
     273                 :            :                 return 0;
     274                 :            : 
     275                 :          0 :         set_bit(_WDOG_KEEPALIVE, &wd_data->status);
     276                 :            : 
     277                 :          0 :         started_at = ktime_get();
     278                 :          0 :         if (watchdog_hw_running(wdd) && wdd->ops->ping)
     279                 :          0 :                 err = wdd->ops->ping(wdd);
     280                 :            :         else
     281                 :          0 :                 err = wdd->ops->start(wdd);
     282                 :          0 :         if (err == 0) {
     283                 :          0 :                 set_bit(WDOG_ACTIVE, &wdd->status);
     284                 :          0 :                 wd_data->last_keepalive = started_at;
     285                 :          0 :                 wd_data->last_hw_keepalive = started_at;
     286                 :          0 :                 watchdog_update_worker(wdd);
     287                 :            :         }
     288                 :            : 
     289                 :          0 :         return err;
     290                 :            : }
     291                 :            : 
     292                 :            : /*
     293                 :            :  *      watchdog_stop: wrapper to stop the watchdog.
     294                 :            :  *      @wdd: the watchdog device to stop
     295                 :            :  *
     296                 :            :  *      The caller must hold wd_data->lock.
     297                 :            :  *
     298                 :            :  *      Stop the watchdog if it is still active and unmark it active.
     299                 :            :  *      This function returns zero on success or a negative errno code for
     300                 :            :  *      failure.
     301                 :            :  *      If the 'nowayout' feature was set, the watchdog cannot be stopped.
     302                 :            :  */
     303                 :            : 
     304                 :          0 : static int watchdog_stop(struct watchdog_device *wdd)
     305                 :            : {
     306                 :            :         int err = 0;
     307                 :            : 
     308                 :          0 :         if (!watchdog_active(wdd))
     309                 :            :                 return 0;
     310                 :            : 
     311                 :          0 :         if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
     312                 :          0 :                 pr_info("watchdog%d: nowayout prevents watchdog being stopped!\n",
     313                 :            :                         wdd->id);
     314                 :          0 :                 return -EBUSY;
     315                 :            :         }
     316                 :            : 
     317                 :          0 :         if (wdd->ops->stop) {
     318                 :          0 :                 clear_bit(WDOG_HW_RUNNING, &wdd->status);
     319                 :          0 :                 err = wdd->ops->stop(wdd);
     320                 :            :         } else {
     321                 :          0 :                 set_bit(WDOG_HW_RUNNING, &wdd->status);
     322                 :            :         }
     323                 :            : 
     324                 :          0 :         if (err == 0) {
     325                 :          0 :                 clear_bit(WDOG_ACTIVE, &wdd->status);
     326                 :          0 :                 watchdog_update_worker(wdd);
     327                 :            :         }
     328                 :            : 
     329                 :          0 :         return err;
     330                 :            : }
     331                 :            : 
     332                 :            : /*
     333                 :            :  *      watchdog_get_status: wrapper to get the watchdog status
     334                 :            :  *      @wdd: the watchdog device to get the status from
     335                 :            :  *
     336                 :            :  *      The caller must hold wd_data->lock.
     337                 :            :  *
     338                 :            :  *      Get the watchdog's status flags.
     339                 :            :  */
     340                 :            : 
     341                 :          0 : static unsigned int watchdog_get_status(struct watchdog_device *wdd)
     342                 :            : {
     343                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
     344                 :            :         unsigned int status;
     345                 :            : 
     346                 :          0 :         if (wdd->ops->status)
     347                 :          0 :                 status = wdd->ops->status(wdd);
     348                 :            :         else
     349                 :          0 :                 status = wdd->bootstatus & (WDIOF_CARDRESET |
     350                 :            :                                             WDIOF_OVERHEAT |
     351                 :            :                                             WDIOF_FANFAULT |
     352                 :            :                                             WDIOF_EXTERN1 |
     353                 :            :                                             WDIOF_EXTERN2 |
     354                 :            :                                             WDIOF_POWERUNDER |
     355                 :            :                                             WDIOF_POWEROVER);
     356                 :            : 
     357                 :          0 :         if (test_bit(_WDOG_ALLOW_RELEASE, &wd_data->status))
     358                 :          0 :                 status |= WDIOF_MAGICCLOSE;
     359                 :            : 
     360                 :          0 :         if (test_and_clear_bit(_WDOG_KEEPALIVE, &wd_data->status))
     361                 :          0 :                 status |= WDIOF_KEEPALIVEPING;
     362                 :            : 
     363                 :          0 :         return status;
     364                 :            : }
     365                 :            : 
     366                 :            : /*
     367                 :            :  *      watchdog_set_timeout: set the watchdog timer timeout
     368                 :            :  *      @wdd: the watchdog device to set the timeout for
     369                 :            :  *      @timeout: timeout to set in seconds
     370                 :            :  *
     371                 :            :  *      The caller must hold wd_data->lock.
     372                 :            :  */
     373                 :            : 
     374                 :          0 : static int watchdog_set_timeout(struct watchdog_device *wdd,
     375                 :            :                                                         unsigned int timeout)
     376                 :            : {
     377                 :            :         int err = 0;
     378                 :            : 
     379                 :          0 :         if (!(wdd->info->options & WDIOF_SETTIMEOUT))
     380                 :            :                 return -EOPNOTSUPP;
     381                 :            : 
     382                 :          0 :         if (watchdog_timeout_invalid(wdd, timeout))
     383                 :            :                 return -EINVAL;
     384                 :            : 
     385                 :          0 :         if (wdd->ops->set_timeout) {
     386                 :          0 :                 err = wdd->ops->set_timeout(wdd, timeout);
     387                 :            :         } else {
     388                 :          0 :                 wdd->timeout = timeout;
     389                 :            :                 /* Disable pretimeout if it doesn't fit the new timeout */
     390                 :          0 :                 if (wdd->pretimeout >= wdd->timeout)
     391                 :          0 :                         wdd->pretimeout = 0;
     392                 :            :         }
     393                 :            : 
     394                 :          0 :         watchdog_update_worker(wdd);
     395                 :            : 
     396                 :          0 :         return err;
     397                 :            : }
     398                 :            : 
     399                 :            : /*
     400                 :            :  *      watchdog_set_pretimeout: set the watchdog timer pretimeout
     401                 :            :  *      @wdd: the watchdog device to set the timeout for
     402                 :            :  *      @timeout: pretimeout to set in seconds
     403                 :            :  */
     404                 :            : 
     405                 :          0 : static int watchdog_set_pretimeout(struct watchdog_device *wdd,
     406                 :            :                                    unsigned int timeout)
     407                 :            : {
     408                 :            :         int err = 0;
     409                 :            : 
     410                 :          0 :         if (!(wdd->info->options & WDIOF_PRETIMEOUT))
     411                 :            :                 return -EOPNOTSUPP;
     412                 :            : 
     413                 :          0 :         if (watchdog_pretimeout_invalid(wdd, timeout))
     414                 :            :                 return -EINVAL;
     415                 :            : 
     416                 :          0 :         if (wdd->ops->set_pretimeout)
     417                 :          0 :                 err = wdd->ops->set_pretimeout(wdd, timeout);
     418                 :            :         else
     419                 :          0 :                 wdd->pretimeout = timeout;
     420                 :            : 
     421                 :          0 :         return err;
     422                 :            : }
     423                 :            : 
     424                 :            : /*
     425                 :            :  *      watchdog_get_timeleft: wrapper to get the time left before a reboot
     426                 :            :  *      @wdd: the watchdog device to get the remaining time from
     427                 :            :  *      @timeleft: the time that's left
     428                 :            :  *
     429                 :            :  *      The caller must hold wd_data->lock.
     430                 :            :  *
     431                 :            :  *      Get the time before a watchdog will reboot (if not pinged).
     432                 :            :  */
     433                 :            : 
     434                 :            : static int watchdog_get_timeleft(struct watchdog_device *wdd,
     435                 :            :                                                         unsigned int *timeleft)
     436                 :            : {
     437                 :            :         *timeleft = 0;
     438                 :            : 
     439                 :          0 :         if (!wdd->ops->get_timeleft)
     440                 :            :                 return -EOPNOTSUPP;
     441                 :            : 
     442                 :          0 :         *timeleft = wdd->ops->get_timeleft(wdd);
     443                 :            : 
     444                 :            :         return 0;
     445                 :            : }
     446                 :            : 
     447                 :            : #ifdef CONFIG_WATCHDOG_SYSFS
     448                 :            : static ssize_t nowayout_show(struct device *dev, struct device_attribute *attr,
     449                 :            :                                 char *buf)
     450                 :            : {
     451                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     452                 :            : 
     453                 :            :         return sprintf(buf, "%d\n", !!test_bit(WDOG_NO_WAY_OUT, &wdd->status));
     454                 :            : }
     455                 :            : static DEVICE_ATTR_RO(nowayout);
     456                 :            : 
     457                 :            : static ssize_t status_show(struct device *dev, struct device_attribute *attr,
     458                 :            :                                 char *buf)
     459                 :            : {
     460                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     461                 :            :         struct watchdog_core_data *wd_data = wdd->wd_data;
     462                 :            :         unsigned int status;
     463                 :            : 
     464                 :            :         mutex_lock(&wd_data->lock);
     465                 :            :         status = watchdog_get_status(wdd);
     466                 :            :         mutex_unlock(&wd_data->lock);
     467                 :            : 
     468                 :            :         return sprintf(buf, "0x%x\n", status);
     469                 :            : }
     470                 :            : static DEVICE_ATTR_RO(status);
     471                 :            : 
     472                 :            : static ssize_t bootstatus_show(struct device *dev,
     473                 :            :                                 struct device_attribute *attr, char *buf)
     474                 :            : {
     475                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     476                 :            : 
     477                 :            :         return sprintf(buf, "%u\n", wdd->bootstatus);
     478                 :            : }
     479                 :            : static DEVICE_ATTR_RO(bootstatus);
     480                 :            : 
     481                 :            : static ssize_t timeleft_show(struct device *dev, struct device_attribute *attr,
     482                 :            :                                 char *buf)
     483                 :            : {
     484                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     485                 :            :         struct watchdog_core_data *wd_data = wdd->wd_data;
     486                 :            :         ssize_t status;
     487                 :            :         unsigned int val;
     488                 :            : 
     489                 :            :         mutex_lock(&wd_data->lock);
     490                 :            :         status = watchdog_get_timeleft(wdd, &val);
     491                 :            :         mutex_unlock(&wd_data->lock);
     492                 :            :         if (!status)
     493                 :            :                 status = sprintf(buf, "%u\n", val);
     494                 :            : 
     495                 :            :         return status;
     496                 :            : }
     497                 :            : static DEVICE_ATTR_RO(timeleft);
     498                 :            : 
     499                 :            : static ssize_t timeout_show(struct device *dev, struct device_attribute *attr,
     500                 :            :                                 char *buf)
     501                 :            : {
     502                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     503                 :            : 
     504                 :            :         return sprintf(buf, "%u\n", wdd->timeout);
     505                 :            : }
     506                 :            : static DEVICE_ATTR_RO(timeout);
     507                 :            : 
     508                 :            : static ssize_t pretimeout_show(struct device *dev,
     509                 :            :                                struct device_attribute *attr, char *buf)
     510                 :            : {
     511                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     512                 :            : 
     513                 :            :         return sprintf(buf, "%u\n", wdd->pretimeout);
     514                 :            : }
     515                 :            : static DEVICE_ATTR_RO(pretimeout);
     516                 :            : 
     517                 :            : static ssize_t identity_show(struct device *dev, struct device_attribute *attr,
     518                 :            :                                 char *buf)
     519                 :            : {
     520                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     521                 :            : 
     522                 :            :         return sprintf(buf, "%s\n", wdd->info->identity);
     523                 :            : }
     524                 :            : static DEVICE_ATTR_RO(identity);
     525                 :            : 
     526                 :            : static ssize_t state_show(struct device *dev, struct device_attribute *attr,
     527                 :            :                                 char *buf)
     528                 :            : {
     529                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     530                 :            : 
     531                 :            :         if (watchdog_active(wdd))
     532                 :            :                 return sprintf(buf, "active\n");
     533                 :            : 
     534                 :            :         return sprintf(buf, "inactive\n");
     535                 :            : }
     536                 :            : static DEVICE_ATTR_RO(state);
     537                 :            : 
     538                 :            : static ssize_t pretimeout_available_governors_show(struct device *dev,
     539                 :            :                                    struct device_attribute *attr, char *buf)
     540                 :            : {
     541                 :            :         return watchdog_pretimeout_available_governors_get(buf);
     542                 :            : }
     543                 :            : static DEVICE_ATTR_RO(pretimeout_available_governors);
     544                 :            : 
     545                 :            : static ssize_t pretimeout_governor_show(struct device *dev,
     546                 :            :                                         struct device_attribute *attr,
     547                 :            :                                         char *buf)
     548                 :            : {
     549                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     550                 :            : 
     551                 :            :         return watchdog_pretimeout_governor_get(wdd, buf);
     552                 :            : }
     553                 :            : 
     554                 :            : static ssize_t pretimeout_governor_store(struct device *dev,
     555                 :            :                                          struct device_attribute *attr,
     556                 :            :                                          const char *buf, size_t count)
     557                 :            : {
     558                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     559                 :            :         int ret = watchdog_pretimeout_governor_set(wdd, buf);
     560                 :            : 
     561                 :            :         if (!ret)
     562                 :            :                 ret = count;
     563                 :            : 
     564                 :            :         return ret;
     565                 :            : }
     566                 :            : static DEVICE_ATTR_RW(pretimeout_governor);
     567                 :            : 
     568                 :            : static umode_t wdt_is_visible(struct kobject *kobj, struct attribute *attr,
     569                 :            :                                 int n)
     570                 :            : {
     571                 :            :         struct device *dev = container_of(kobj, struct device, kobj);
     572                 :            :         struct watchdog_device *wdd = dev_get_drvdata(dev);
     573                 :            :         umode_t mode = attr->mode;
     574                 :            : 
     575                 :            :         if (attr == &dev_attr_timeleft.attr && !wdd->ops->get_timeleft)
     576                 :            :                 mode = 0;
     577                 :            :         else if (attr == &dev_attr_pretimeout.attr &&
     578                 :            :                  !(wdd->info->options & WDIOF_PRETIMEOUT))
     579                 :            :                 mode = 0;
     580                 :            :         else if ((attr == &dev_attr_pretimeout_governor.attr ||
     581                 :            :                   attr == &dev_attr_pretimeout_available_governors.attr) &&
     582                 :            :                  (!(wdd->info->options & WDIOF_PRETIMEOUT) ||
     583                 :            :                   !IS_ENABLED(CONFIG_WATCHDOG_PRETIMEOUT_GOV)))
     584                 :            :                 mode = 0;
     585                 :            : 
     586                 :            :         return mode;
     587                 :            : }
     588                 :            : static struct attribute *wdt_attrs[] = {
     589                 :            :         &dev_attr_state.attr,
     590                 :            :         &dev_attr_identity.attr,
     591                 :            :         &dev_attr_timeout.attr,
     592                 :            :         &dev_attr_pretimeout.attr,
     593                 :            :         &dev_attr_timeleft.attr,
     594                 :            :         &dev_attr_bootstatus.attr,
     595                 :            :         &dev_attr_status.attr,
     596                 :            :         &dev_attr_nowayout.attr,
     597                 :            :         &dev_attr_pretimeout_governor.attr,
     598                 :            :         &dev_attr_pretimeout_available_governors.attr,
     599                 :            :         NULL,
     600                 :            : };
     601                 :            : 
     602                 :            : static const struct attribute_group wdt_group = {
     603                 :            :         .attrs = wdt_attrs,
     604                 :            :         .is_visible = wdt_is_visible,
     605                 :            : };
     606                 :            : __ATTRIBUTE_GROUPS(wdt);
     607                 :            : #else
     608                 :            : #define wdt_groups      NULL
     609                 :            : #endif
     610                 :            : 
     611                 :            : /*
     612                 :            :  *      watchdog_ioctl_op: call the watchdog drivers ioctl op if defined
     613                 :            :  *      @wdd: the watchdog device to do the ioctl on
     614                 :            :  *      @cmd: watchdog command
     615                 :            :  *      @arg: argument pointer
     616                 :            :  *
     617                 :            :  *      The caller must hold wd_data->lock.
     618                 :            :  */
     619                 :            : 
     620                 :            : static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
     621                 :            :                                                         unsigned long arg)
     622                 :            : {
     623                 :          0 :         if (!wdd->ops->ioctl)
     624                 :            :                 return -ENOIOCTLCMD;
     625                 :            : 
     626                 :          0 :         return wdd->ops->ioctl(wdd, cmd, arg);
     627                 :            : }
     628                 :            : 
     629                 :            : /*
     630                 :            :  *      watchdog_write: writes to the watchdog.
     631                 :            :  *      @file: file from VFS
     632                 :            :  *      @data: user address of data
     633                 :            :  *      @len: length of data
     634                 :            :  *      @ppos: pointer to the file offset
     635                 :            :  *
     636                 :            :  *      A write to a watchdog device is defined as a keepalive ping.
     637                 :            :  *      Writing the magic 'V' sequence allows the next close to turn
     638                 :            :  *      off the watchdog (if 'nowayout' is not set).
     639                 :            :  */
     640                 :            : 
     641                 :          0 : static ssize_t watchdog_write(struct file *file, const char __user *data,
     642                 :            :                                                 size_t len, loff_t *ppos)
     643                 :            : {
     644                 :          0 :         struct watchdog_core_data *wd_data = file->private_data;
     645                 :            :         struct watchdog_device *wdd;
     646                 :            :         int err;
     647                 :            :         size_t i;
     648                 :            :         char c;
     649                 :            : 
     650                 :          0 :         if (len == 0)
     651                 :            :                 return 0;
     652                 :            : 
     653                 :            :         /*
     654                 :            :          * Note: just in case someone wrote the magic character
     655                 :            :          * five months ago...
     656                 :            :          */
     657                 :          0 :         clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
     658                 :            : 
     659                 :            :         /* scan to see whether or not we got the magic character */
     660                 :          0 :         for (i = 0; i != len; i++) {
     661                 :          0 :                 if (get_user(c, data + i))
     662                 :            :                         return -EFAULT;
     663                 :          0 :                 if (c == 'V')
     664                 :          0 :                         set_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
     665                 :            :         }
     666                 :            : 
     667                 :            :         /* someone wrote to us, so we send the watchdog a keepalive ping */
     668                 :            : 
     669                 :            :         err = -ENODEV;
     670                 :          0 :         mutex_lock(&wd_data->lock);
     671                 :          0 :         wdd = wd_data->wdd;
     672                 :          0 :         if (wdd)
     673                 :          0 :                 err = watchdog_ping(wdd);
     674                 :          0 :         mutex_unlock(&wd_data->lock);
     675                 :            : 
     676                 :          0 :         if (err < 0)
     677                 :            :                 return err;
     678                 :            : 
     679                 :          0 :         return len;
     680                 :            : }
     681                 :            : 
     682                 :            : /*
     683                 :            :  *      watchdog_ioctl: handle the different ioctl's for the watchdog device.
     684                 :            :  *      @file: file handle to the device
     685                 :            :  *      @cmd: watchdog command
     686                 :            :  *      @arg: argument pointer
     687                 :            :  *
     688                 :            :  *      The watchdog API defines a common set of functions for all watchdogs
     689                 :            :  *      according to their available features.
     690                 :            :  */
     691                 :            : 
     692                 :          0 : static long watchdog_ioctl(struct file *file, unsigned int cmd,
     693                 :            :                                                         unsigned long arg)
     694                 :            : {
     695                 :          0 :         struct watchdog_core_data *wd_data = file->private_data;
     696                 :          0 :         void __user *argp = (void __user *)arg;
     697                 :            :         struct watchdog_device *wdd;
     698                 :            :         int __user *p = argp;
     699                 :            :         unsigned int val;
     700                 :            :         int err;
     701                 :            : 
     702                 :          0 :         mutex_lock(&wd_data->lock);
     703                 :            : 
     704                 :          0 :         wdd = wd_data->wdd;
     705                 :          0 :         if (!wdd) {
     706                 :            :                 err = -ENODEV;
     707                 :            :                 goto out_ioctl;
     708                 :            :         }
     709                 :            : 
     710                 :            :         err = watchdog_ioctl_op(wdd, cmd, arg);
     711                 :          0 :         if (err != -ENOIOCTLCMD)
     712                 :            :                 goto out_ioctl;
     713                 :            : 
     714                 :          0 :         switch (cmd) {
     715                 :            :         case WDIOC_GETSUPPORT:
     716                 :          0 :                 err = copy_to_user(argp, wdd->info,
     717                 :          0 :                         sizeof(struct watchdog_info)) ? -EFAULT : 0;
     718                 :          0 :                 break;
     719                 :            :         case WDIOC_GETSTATUS:
     720                 :          0 :                 val = watchdog_get_status(wdd);
     721                 :          0 :                 err = put_user(val, p);
     722                 :          0 :                 break;
     723                 :            :         case WDIOC_GETBOOTSTATUS:
     724                 :          0 :                 err = put_user(wdd->bootstatus, p);
     725                 :          0 :                 break;
     726                 :            :         case WDIOC_SETOPTIONS:
     727                 :          0 :                 if (get_user(val, p)) {
     728                 :            :                         err = -EFAULT;
     729                 :            :                         break;
     730                 :            :                 }
     731                 :          0 :                 if (val & WDIOS_DISABLECARD) {
     732                 :          0 :                         err = watchdog_stop(wdd);
     733                 :          0 :                         if (err < 0)
     734                 :            :                                 break;
     735                 :            :                 }
     736                 :          0 :                 if (val & WDIOS_ENABLECARD)
     737                 :          0 :                         err = watchdog_start(wdd);
     738                 :            :                 break;
     739                 :            :         case WDIOC_KEEPALIVE:
     740                 :          0 :                 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) {
     741                 :            :                         err = -EOPNOTSUPP;
     742                 :            :                         break;
     743                 :            :                 }
     744                 :          0 :                 err = watchdog_ping(wdd);
     745                 :          0 :                 break;
     746                 :            :         case WDIOC_SETTIMEOUT:
     747                 :          0 :                 if (get_user(val, p)) {
     748                 :            :                         err = -EFAULT;
     749                 :            :                         break;
     750                 :            :                 }
     751                 :          0 :                 err = watchdog_set_timeout(wdd, val);
     752                 :          0 :                 if (err < 0)
     753                 :            :                         break;
     754                 :            :                 /* If the watchdog is active then we send a keepalive ping
     755                 :            :                  * to make sure that the watchdog keep's running (and if
     756                 :            :                  * possible that it takes the new timeout) */
     757                 :          0 :                 err = watchdog_ping(wdd);
     758                 :          0 :                 if (err < 0)
     759                 :            :                         break;
     760                 :            :                 /* fall through */
     761                 :            :         case WDIOC_GETTIMEOUT:
     762                 :            :                 /* timeout == 0 means that we don't know the timeout */
     763                 :          0 :                 if (wdd->timeout == 0) {
     764                 :            :                         err = -EOPNOTSUPP;
     765                 :            :                         break;
     766                 :            :                 }
     767                 :          0 :                 err = put_user(wdd->timeout, p);
     768                 :          0 :                 break;
     769                 :            :         case WDIOC_GETTIMELEFT:
     770                 :            :                 err = watchdog_get_timeleft(wdd, &val);
     771                 :          0 :                 if (err < 0)
     772                 :            :                         break;
     773                 :          0 :                 err = put_user(val, p);
     774                 :          0 :                 break;
     775                 :            :         case WDIOC_SETPRETIMEOUT:
     776                 :          0 :                 if (get_user(val, p)) {
     777                 :            :                         err = -EFAULT;
     778                 :            :                         break;
     779                 :            :                 }
     780                 :          0 :                 err = watchdog_set_pretimeout(wdd, val);
     781                 :          0 :                 break;
     782                 :            :         case WDIOC_GETPRETIMEOUT:
     783                 :          0 :                 err = put_user(wdd->pretimeout, p);
     784                 :          0 :                 break;
     785                 :            :         default:
     786                 :            :                 err = -ENOTTY;
     787                 :            :                 break;
     788                 :            :         }
     789                 :            : 
     790                 :            : out_ioctl:
     791                 :          0 :         mutex_unlock(&wd_data->lock);
     792                 :          0 :         return err;
     793                 :            : }
     794                 :            : 
     795                 :            : /*
     796                 :            :  *      watchdog_open: open the /dev/watchdog* devices.
     797                 :            :  *      @inode: inode of device
     798                 :            :  *      @file: file handle to device
     799                 :            :  *
     800                 :            :  *      When the /dev/watchdog* device gets opened, we start the watchdog.
     801                 :            :  *      Watch out: the /dev/watchdog device is single open, so we make sure
     802                 :            :  *      it can only be opened once.
     803                 :            :  */
     804                 :            : 
     805                 :          0 : static int watchdog_open(struct inode *inode, struct file *file)
     806                 :            : {
     807                 :            :         struct watchdog_core_data *wd_data;
     808                 :            :         struct watchdog_device *wdd;
     809                 :            :         bool hw_running;
     810                 :            :         int err;
     811                 :            : 
     812                 :            :         /* Get the corresponding watchdog device */
     813                 :          0 :         if (imajor(inode) == MISC_MAJOR)
     814                 :          0 :                 wd_data = old_wd_data;
     815                 :            :         else
     816                 :          0 :                 wd_data = container_of(inode->i_cdev, struct watchdog_core_data,
     817                 :            :                                        cdev);
     818                 :            : 
     819                 :            :         /* the watchdog is single open! */
     820                 :          0 :         if (test_and_set_bit(_WDOG_DEV_OPEN, &wd_data->status))
     821                 :            :                 return -EBUSY;
     822                 :            : 
     823                 :          0 :         wdd = wd_data->wdd;
     824                 :            : 
     825                 :            :         /*
     826                 :            :          * If the /dev/watchdog device is open, we don't want the module
     827                 :            :          * to be unloaded.
     828                 :            :          */
     829                 :            :         hw_running = watchdog_hw_running(wdd);
     830                 :          0 :         if (!hw_running && !try_module_get(wdd->ops->owner)) {
     831                 :            :                 err = -EBUSY;
     832                 :            :                 goto out_clear;
     833                 :            :         }
     834                 :            : 
     835                 :          0 :         err = watchdog_start(wdd);
     836                 :          0 :         if (err < 0)
     837                 :            :                 goto out_mod;
     838                 :            : 
     839                 :          0 :         file->private_data = wd_data;
     840                 :            : 
     841                 :          0 :         if (!hw_running)
     842                 :          0 :                 get_device(&wd_data->dev);
     843                 :            : 
     844                 :            :         /*
     845                 :            :          * open_timeout only applies for the first open from
     846                 :            :          * userspace. Set open_deadline to infinity so that the kernel
     847                 :            :          * will take care of an always-running hardware watchdog in
     848                 :            :          * case the device gets magic-closed or WDIOS_DISABLECARD is
     849                 :            :          * applied.
     850                 :            :          */
     851                 :          0 :         wd_data->open_deadline = KTIME_MAX;
     852                 :            : 
     853                 :            :         /* dev/watchdog is a virtual (and thus non-seekable) filesystem */
     854                 :          0 :         return stream_open(inode, file);
     855                 :            : 
     856                 :            : out_mod:
     857                 :          0 :         module_put(wd_data->wdd->ops->owner);
     858                 :            : out_clear:
     859                 :          0 :         clear_bit(_WDOG_DEV_OPEN, &wd_data->status);
     860                 :          0 :         return err;
     861                 :            : }
     862                 :            : 
     863                 :          0 : static void watchdog_core_data_release(struct device *dev)
     864                 :            : {
     865                 :            :         struct watchdog_core_data *wd_data;
     866                 :            : 
     867                 :            :         wd_data = container_of(dev, struct watchdog_core_data, dev);
     868                 :            : 
     869                 :          0 :         kfree(wd_data);
     870                 :          0 : }
     871                 :            : 
     872                 :            : /*
     873                 :            :  *      watchdog_release: release the watchdog device.
     874                 :            :  *      @inode: inode of device
     875                 :            :  *      @file: file handle to device
     876                 :            :  *
     877                 :            :  *      This is the code for when /dev/watchdog gets closed. We will only
     878                 :            :  *      stop the watchdog when we have received the magic char (and nowayout
     879                 :            :  *      was not set), else the watchdog will keep running.
     880                 :            :  */
     881                 :            : 
     882                 :          0 : static int watchdog_release(struct inode *inode, struct file *file)
     883                 :            : {
     884                 :          0 :         struct watchdog_core_data *wd_data = file->private_data;
     885                 :            :         struct watchdog_device *wdd;
     886                 :            :         int err = -EBUSY;
     887                 :            :         bool running;
     888                 :            : 
     889                 :          0 :         mutex_lock(&wd_data->lock);
     890                 :            : 
     891                 :          0 :         wdd = wd_data->wdd;
     892                 :          0 :         if (!wdd)
     893                 :            :                 goto done;
     894                 :            : 
     895                 :            :         /*
     896                 :            :          * We only stop the watchdog if we received the magic character
     897                 :            :          * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
     898                 :            :          * watchdog_stop will fail.
     899                 :            :          */
     900                 :          0 :         if (!test_bit(WDOG_ACTIVE, &wdd->status))
     901                 :            :                 err = 0;
     902                 :          0 :         else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status) ||
     903                 :          0 :                  !(wdd->info->options & WDIOF_MAGICCLOSE))
     904                 :          0 :                 err = watchdog_stop(wdd);
     905                 :            : 
     906                 :            :         /* If the watchdog was not stopped, send a keepalive ping */
     907                 :          0 :         if (err < 0) {
     908                 :          0 :                 pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id);
     909                 :          0 :                 watchdog_ping(wdd);
     910                 :            :         }
     911                 :            : 
     912                 :          0 :         watchdog_update_worker(wdd);
     913                 :            : 
     914                 :            :         /* make sure that /dev/watchdog can be re-opened */
     915                 :          0 :         clear_bit(_WDOG_DEV_OPEN, &wd_data->status);
     916                 :            : 
     917                 :            : done:
     918                 :          0 :         running = wdd && watchdog_hw_running(wdd);
     919                 :          0 :         mutex_unlock(&wd_data->lock);
     920                 :            :         /*
     921                 :            :          * Allow the owner module to be unloaded again unless the watchdog
     922                 :            :          * is still running. If the watchdog is still running, it can not
     923                 :            :          * be stopped, and its driver must not be unloaded.
     924                 :            :          */
     925                 :          0 :         if (!running) {
     926                 :          0 :                 module_put(wd_data->cdev.owner);
     927                 :          0 :                 put_device(&wd_data->dev);
     928                 :            :         }
     929                 :          0 :         return 0;
     930                 :            : }
     931                 :            : 
     932                 :            : static const struct file_operations watchdog_fops = {
     933                 :            :         .owner          = THIS_MODULE,
     934                 :            :         .write          = watchdog_write,
     935                 :            :         .unlocked_ioctl = watchdog_ioctl,
     936                 :            :         .open           = watchdog_open,
     937                 :            :         .release        = watchdog_release,
     938                 :            : };
     939                 :            : 
     940                 :            : static struct miscdevice watchdog_miscdev = {
     941                 :            :         .minor          = WATCHDOG_MINOR,
     942                 :            :         .name           = "watchdog",
     943                 :            :         .fops           = &watchdog_fops,
     944                 :            : };
     945                 :            : 
     946                 :            : static struct class watchdog_class = {
     947                 :            :         .name =         "watchdog",
     948                 :            :         .owner =        THIS_MODULE,
     949                 :            :         .dev_groups =   wdt_groups,
     950                 :            : };
     951                 :            : 
     952                 :            : /*
     953                 :            :  *      watchdog_cdev_register: register watchdog character device
     954                 :            :  *      @wdd: watchdog device
     955                 :            :  *
     956                 :            :  *      Register a watchdog character device including handling the legacy
     957                 :            :  *      /dev/watchdog node. /dev/watchdog is actually a miscdevice and
     958                 :            :  *      thus we set it up like that.
     959                 :            :  */
     960                 :            : 
     961                 :          3 : static int watchdog_cdev_register(struct watchdog_device *wdd)
     962                 :            : {
     963                 :            :         struct watchdog_core_data *wd_data;
     964                 :            :         int err;
     965                 :            : 
     966                 :          3 :         wd_data = kzalloc(sizeof(struct watchdog_core_data), GFP_KERNEL);
     967                 :          3 :         if (!wd_data)
     968                 :            :                 return -ENOMEM;
     969                 :          3 :         mutex_init(&wd_data->lock);
     970                 :            : 
     971                 :          3 :         wd_data->wdd = wdd;
     972                 :          3 :         wdd->wd_data = wd_data;
     973                 :            : 
     974                 :          3 :         if (IS_ERR_OR_NULL(watchdog_kworker))
     975                 :            :                 return -ENODEV;
     976                 :            : 
     977                 :          3 :         device_initialize(&wd_data->dev);
     978                 :          3 :         wd_data->dev.devt = MKDEV(MAJOR(watchdog_devt), wdd->id);
     979                 :          3 :         wd_data->dev.class = &watchdog_class;
     980                 :          3 :         wd_data->dev.parent = wdd->parent;
     981                 :          3 :         wd_data->dev.groups = wdd->groups;
     982                 :          3 :         wd_data->dev.release = watchdog_core_data_release;
     983                 :            :         dev_set_drvdata(&wd_data->dev, wdd);
     984                 :          3 :         dev_set_name(&wd_data->dev, "watchdog%d", wdd->id);
     985                 :            : 
     986                 :          3 :         kthread_init_work(&wd_data->work, watchdog_ping_work);
     987                 :          3 :         hrtimer_init(&wd_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_HARD);
     988                 :          3 :         wd_data->timer.function = watchdog_timer_expired;
     989                 :            : 
     990                 :          3 :         if (wdd->id == 0) {
     991                 :          3 :                 old_wd_data = wd_data;
     992                 :          3 :                 watchdog_miscdev.parent = wdd->parent;
     993                 :          3 :                 err = misc_register(&watchdog_miscdev);
     994                 :          3 :                 if (err != 0) {
     995                 :          0 :                         pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
     996                 :            :                                 wdd->info->identity, WATCHDOG_MINOR, err);
     997                 :          0 :                         if (err == -EBUSY)
     998                 :          0 :                                 pr_err("%s: a legacy watchdog module is probably present.\n",
     999                 :            :                                         wdd->info->identity);
    1000                 :          0 :                         old_wd_data = NULL;
    1001                 :          0 :                         kfree(wd_data);
    1002                 :          0 :                         return err;
    1003                 :            :                 }
    1004                 :            :         }
    1005                 :            : 
    1006                 :            :         /* Fill in the data structures */
    1007                 :          3 :         cdev_init(&wd_data->cdev, &watchdog_fops);
    1008                 :            : 
    1009                 :            :         /* Add the device */
    1010                 :          3 :         err = cdev_device_add(&wd_data->cdev, &wd_data->dev);
    1011                 :          3 :         if (err) {
    1012                 :          0 :                 pr_err("watchdog%d unable to add device %d:%d\n",
    1013                 :            :                         wdd->id,  MAJOR(watchdog_devt), wdd->id);
    1014                 :          0 :                 if (wdd->id == 0) {
    1015                 :          0 :                         misc_deregister(&watchdog_miscdev);
    1016                 :          0 :                         old_wd_data = NULL;
    1017                 :          0 :                         put_device(&wd_data->dev);
    1018                 :            :                 }
    1019                 :          0 :                 return err;
    1020                 :            :         }
    1021                 :            : 
    1022                 :          3 :         wd_data->cdev.owner = wdd->ops->owner;
    1023                 :            : 
    1024                 :            :         /* Record time of most recent heartbeat as 'just before now'. */
    1025                 :          3 :         wd_data->last_hw_keepalive = ktime_sub(ktime_get(), 1);
    1026                 :          3 :         watchdog_set_open_deadline(wd_data);
    1027                 :            : 
    1028                 :            :         /*
    1029                 :            :          * If the watchdog is running, prevent its driver from being unloaded,
    1030                 :            :          * and schedule an immediate ping.
    1031                 :            :          */
    1032                 :          3 :         if (watchdog_hw_running(wdd)) {
    1033                 :          0 :                 __module_get(wdd->ops->owner);
    1034                 :          0 :                 get_device(&wd_data->dev);
    1035                 :          0 :                 if (handle_boot_enabled)
    1036                 :            :                         hrtimer_start(&wd_data->timer, 0,
    1037                 :            :                                       HRTIMER_MODE_REL_HARD);
    1038                 :            :                 else
    1039                 :          0 :                         pr_info("watchdog%d running and kernel based pre-userspace handler disabled\n",
    1040                 :            :                                 wdd->id);
    1041                 :            :         }
    1042                 :            : 
    1043                 :            :         return 0;
    1044                 :            : }
    1045                 :            : 
    1046                 :            : /*
    1047                 :            :  *      watchdog_cdev_unregister: unregister watchdog character device
    1048                 :            :  *      @watchdog: watchdog device
    1049                 :            :  *
    1050                 :            :  *      Unregister watchdog character device and if needed the legacy
    1051                 :            :  *      /dev/watchdog device.
    1052                 :            :  */
    1053                 :            : 
    1054                 :          0 : static void watchdog_cdev_unregister(struct watchdog_device *wdd)
    1055                 :            : {
    1056                 :          0 :         struct watchdog_core_data *wd_data = wdd->wd_data;
    1057                 :            : 
    1058                 :          0 :         cdev_device_del(&wd_data->cdev, &wd_data->dev);
    1059                 :          0 :         if (wdd->id == 0) {
    1060                 :          0 :                 misc_deregister(&watchdog_miscdev);
    1061                 :          0 :                 old_wd_data = NULL;
    1062                 :            :         }
    1063                 :            : 
    1064                 :          0 :         if (watchdog_active(wdd) &&
    1065                 :            :             test_bit(WDOG_STOP_ON_UNREGISTER, &wdd->status)) {
    1066                 :          0 :                 watchdog_stop(wdd);
    1067                 :            :         }
    1068                 :            : 
    1069                 :          0 :         mutex_lock(&wd_data->lock);
    1070                 :          0 :         wd_data->wdd = NULL;
    1071                 :          0 :         wdd->wd_data = NULL;
    1072                 :          0 :         mutex_unlock(&wd_data->lock);
    1073                 :            : 
    1074                 :          0 :         hrtimer_cancel(&wd_data->timer);
    1075                 :          0 :         kthread_cancel_work_sync(&wd_data->work);
    1076                 :            : 
    1077                 :          0 :         put_device(&wd_data->dev);
    1078                 :          0 : }
    1079                 :            : 
    1080                 :            : /*
    1081                 :            :  *      watchdog_dev_register: register a watchdog device
    1082                 :            :  *      @wdd: watchdog device
    1083                 :            :  *
    1084                 :            :  *      Register a watchdog device including handling the legacy
    1085                 :            :  *      /dev/watchdog node. /dev/watchdog is actually a miscdevice and
    1086                 :            :  *      thus we set it up like that.
    1087                 :            :  */
    1088                 :            : 
    1089                 :          3 : int watchdog_dev_register(struct watchdog_device *wdd)
    1090                 :            : {
    1091                 :            :         int ret;
    1092                 :            : 
    1093                 :          3 :         ret = watchdog_cdev_register(wdd);
    1094                 :          3 :         if (ret)
    1095                 :          0 :                 return ret;
    1096                 :            : 
    1097                 :            :         ret = watchdog_register_pretimeout(wdd);
    1098                 :            :         if (ret)
    1099                 :            :                 watchdog_cdev_unregister(wdd);
    1100                 :            : 
    1101                 :            :         return ret;
    1102                 :            : }
    1103                 :            : 
    1104                 :            : /*
    1105                 :            :  *      watchdog_dev_unregister: unregister a watchdog device
    1106                 :            :  *      @watchdog: watchdog device
    1107                 :            :  *
    1108                 :            :  *      Unregister watchdog device and if needed the legacy
    1109                 :            :  *      /dev/watchdog device.
    1110                 :            :  */
    1111                 :            : 
    1112                 :          0 : void watchdog_dev_unregister(struct watchdog_device *wdd)
    1113                 :            : {
    1114                 :            :         watchdog_unregister_pretimeout(wdd);
    1115                 :          0 :         watchdog_cdev_unregister(wdd);
    1116                 :          0 : }
    1117                 :            : 
    1118                 :            : /*
    1119                 :            :  *      watchdog_dev_init: init dev part of watchdog core
    1120                 :            :  *
    1121                 :            :  *      Allocate a range of chardev nodes to use for watchdog devices
    1122                 :            :  */
    1123                 :            : 
    1124                 :          3 : int __init watchdog_dev_init(void)
    1125                 :            : {
    1126                 :            :         int err;
    1127                 :          3 :         struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1,};
    1128                 :            : 
    1129                 :          3 :         watchdog_kworker = kthread_create_worker(0, "watchdogd");
    1130                 :          3 :         if (IS_ERR(watchdog_kworker)) {
    1131                 :          0 :                 pr_err("Failed to create watchdog kworker\n");
    1132                 :          0 :                 return PTR_ERR(watchdog_kworker);
    1133                 :            :         }
    1134                 :          3 :         sched_setscheduler(watchdog_kworker->task, SCHED_FIFO, &param);
    1135                 :            : 
    1136                 :          3 :         err = class_register(&watchdog_class);
    1137                 :          3 :         if (err < 0) {
    1138                 :          0 :                 pr_err("couldn't register class\n");
    1139                 :          0 :                 goto err_register;
    1140                 :            :         }
    1141                 :            : 
    1142                 :          3 :         err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog");
    1143                 :          3 :         if (err < 0) {
    1144                 :          0 :                 pr_err("watchdog: unable to allocate char dev region\n");
    1145                 :            :                 goto err_alloc;
    1146                 :            :         }
    1147                 :            : 
    1148                 :            :         return 0;
    1149                 :            : 
    1150                 :            : err_alloc:
    1151                 :          0 :         class_unregister(&watchdog_class);
    1152                 :            : err_register:
    1153                 :          0 :         kthread_destroy_worker(watchdog_kworker);
    1154                 :          0 :         return err;
    1155                 :            : }
    1156                 :            : 
    1157                 :            : /*
    1158                 :            :  *      watchdog_dev_exit: exit dev part of watchdog core
    1159                 :            :  *
    1160                 :            :  *      Release the range of chardev nodes used for watchdog devices
    1161                 :            :  */
    1162                 :            : 
    1163                 :          0 : void __exit watchdog_dev_exit(void)
    1164                 :            : {
    1165                 :          0 :         unregister_chrdev_region(watchdog_devt, MAX_DOGS);
    1166                 :          0 :         class_unregister(&watchdog_class);
    1167                 :          0 :         kthread_destroy_worker(watchdog_kworker);
    1168                 :          0 : }
    1169                 :            : 
    1170                 :            : module_param(handle_boot_enabled, bool, 0444);
    1171                 :            : MODULE_PARM_DESC(handle_boot_enabled,
    1172                 :            :         "Watchdog core auto-updates boot enabled watchdogs before userspace takes over (default="
    1173                 :            :         __MODULE_STRING(IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED)) ")");
    1174                 :            : 
    1175                 :            : module_param(open_timeout, uint, 0644);
    1176                 :            : MODULE_PARM_DESC(open_timeout,
    1177                 :            :         "Maximum time (in seconds, 0 means infinity) for userspace to take over a running watchdog (default="
    1178                 :            :         __MODULE_STRING(CONFIG_WATCHDOG_OPEN_TIMEOUT) ")");
    

Generated by: LCOV version 1.14