/*      $NetBSD: sysmon_wdog.c,v 1.30 2021/12/31 11:05:41 riastradh Exp $       */

/*-
* Copyright (c) 2000 Zembu Labs, Inc.
* All rights reserved.
*
* Author: Jason R. Thorpe <[email protected]>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by Zembu Labs, Inc.
* 4. Neither the name of Zembu Labs nor the names of its employees may
*    be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY ZEMBU LABS, INC. ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WAR-
* RANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DIS-
* CLAIMED.  IN NO EVENT SHALL ZEMBU LABS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Watchdog timer framework for sysmon.  Hardware (and software)
* watchdog timers can register themselves here to provide a
* watchdog function, which provides an abstract interface to the
* user.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sysmon_wdog.c,v 1.30 2021/12/31 11:05:41 riastradh Exp $");

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/condvar.h>
#include <sys/mutex.h>
#include <sys/callout.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/module.h>
#include <sys/once.h>

#include <dev/sysmon/sysmonvar.h>

static LIST_HEAD(, sysmon_wdog) sysmon_wdog_list =
   LIST_HEAD_INITIALIZER(&sysmon_wdog_list);
static int sysmon_wdog_count;
static kmutex_t sysmon_wdog_list_mtx, sysmon_wdog_mtx;
static kcondvar_t sysmon_wdog_cv;
static struct sysmon_wdog *sysmon_armed_wdog;
static callout_t sysmon_wdog_callout;
static void *sysmon_wdog_sdhook;
static void *sysmon_wdog_cphook;

struct sysmon_wdog *sysmon_wdog_find(const char *);
void    sysmon_wdog_release(struct sysmon_wdog *);
int     sysmon_wdog_setmode(struct sysmon_wdog *, int, u_int);
void    sysmon_wdog_ktickle(void *);
void    sysmon_wdog_critpoll(void *);
void    sysmon_wdog_shutdown(void *);
void    sysmon_wdog_ref(struct sysmon_wdog *);

static struct sysmon_opvec sysmon_wdog_opvec = {
       sysmonopen_wdog, sysmonclose_wdog, sysmonioctl_wdog,
       NULL, NULL, NULL
};

MODULE(MODULE_CLASS_DRIVER, sysmon_wdog, "sysmon");

ONCE_DECL(once_wdog);

static int
wdog_preinit(void)
{

       mutex_init(&sysmon_wdog_list_mtx, MUTEX_DEFAULT, IPL_NONE);
       mutex_init(&sysmon_wdog_mtx, MUTEX_DEFAULT, IPL_SOFTCLOCK);
       cv_init(&sysmon_wdog_cv, "wdogref");
       callout_init(&sysmon_wdog_callout, 0);

       return 0;
}

int
sysmon_wdog_init(void)
{
       int error;

       (void)RUN_ONCE(&once_wdog, wdog_preinit);

       sysmon_wdog_sdhook = shutdownhook_establish(sysmon_wdog_shutdown, NULL);
       if (sysmon_wdog_sdhook == NULL)
               printf("WARNING: unable to register watchdog shutdown hook\n");
       sysmon_wdog_cphook = critpollhook_establish(sysmon_wdog_critpoll, NULL);
       if (sysmon_wdog_cphook == NULL)
               printf("WARNING: unable to register watchdog critpoll hook\n");

       error = sysmon_attach_minor(SYSMON_MINOR_WDOG, &sysmon_wdog_opvec);

       return error;
}

int
sysmon_wdog_fini(void)
{
       int error;

       if ( ! LIST_EMPTY(&sysmon_wdog_list))
               return EBUSY;

       error = sysmon_attach_minor(SYSMON_MINOR_WDOG, NULL);

       if (error == 0) {
               callout_destroy(&sysmon_wdog_callout);
               critpollhook_disestablish(sysmon_wdog_cphook);
               shutdownhook_disestablish(sysmon_wdog_sdhook);
               cv_destroy(&sysmon_wdog_cv);
               mutex_destroy(&sysmon_wdog_mtx);
               mutex_destroy(&sysmon_wdog_list_mtx);
       }

       return error;
}

/*
* sysmonopen_wdog:
*
*      Open the system monitor device.
*/
int
sysmonopen_wdog(dev_t dev, int flag, int mode, struct lwp *l)
{

       return 0;
}

/*
* sysmonclose_wdog:
*
*      Close the system monitor device.
*/
int
sysmonclose_wdog(dev_t dev, int flag, int mode, struct lwp *l)
{
       struct sysmon_wdog *smw;
       int error = 0;

       /*
        * If this is the last close, and there is a watchdog
        * running in UTICKLE mode, we need to disable it,
        * otherwise the system will reset in short order.
        *
        * XXX Maybe we should just go into KTICKLE mode?
        */
       mutex_enter(&sysmon_wdog_mtx);
       if ((smw = sysmon_armed_wdog) != NULL) {
               if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_UTICKLE) {
                       error = sysmon_wdog_setmode(smw,
                           WDOG_MODE_DISARMED, smw->smw_period);
                       if (error) {
                               printf("WARNING: UNABLE TO DISARM "
                                   "WATCHDOG %s ON CLOSE!\n",
                                   smw->smw_name);
                               /*
                                * ...we will probably reboot soon.
                                */
                       }
               }
       }
       mutex_exit(&sysmon_wdog_mtx);

       return error;
}

/*
* sysmonioctl_wdog:
*
*      Perform a watchdog control request.
*/
int
sysmonioctl_wdog(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
       struct sysmon_wdog *smw;
       int error = 0;

       switch (cmd) {
       case WDOGIOC_GMODE:
           {
               struct wdog_mode *wm = (void *) data;

               wm->wm_name[sizeof(wm->wm_name) - 1] = '\0';
               smw = sysmon_wdog_find(wm->wm_name);
               if (smw == NULL) {
                       error = ESRCH;
                       break;
               }

               wm->wm_mode = smw->smw_mode;
               wm->wm_period = smw->smw_period;
               sysmon_wdog_release(smw);
               break;
           }

       case WDOGIOC_SMODE:
           {
               struct wdog_mode *wm = (void *) data;

               if ((flag & FWRITE) == 0) {
                       error = EPERM;
                       break;
               }

               wm->wm_name[sizeof(wm->wm_name) - 1] = '\0';
               smw = sysmon_wdog_find(wm->wm_name);
               if (smw == NULL) {
                       error = ESRCH;
                       break;
               }

               if (wm->wm_mode & ~(WDOG_MODE_MASK|WDOG_FEATURE_MASK))
                       error = EINVAL;
               else {
                       mutex_enter(&sysmon_wdog_mtx);
                       error = sysmon_wdog_setmode(smw, wm->wm_mode,
                           wm->wm_period);
                       mutex_exit(&sysmon_wdog_mtx);
               }

               sysmon_wdog_release(smw);
               break;
           }

       case WDOGIOC_WHICH:
           {
               struct wdog_mode *wm = (void *) data;

               mutex_enter(&sysmon_wdog_mtx);
               if ((smw = sysmon_armed_wdog) != NULL) {
                       strcpy(wm->wm_name, smw->smw_name);
                       wm->wm_mode = smw->smw_mode;
                       wm->wm_period = smw->smw_period;
               } else
                       error = ESRCH;
               mutex_exit(&sysmon_wdog_mtx);
               break;
           }

       case WDOGIOC_TICKLE:
               if ((flag & FWRITE) == 0) {
                       error = EPERM;
                       break;
               }

               mutex_enter(&sysmon_wdog_mtx);
               if ((smw = sysmon_armed_wdog) != NULL) {
                       error = (*smw->smw_tickle)(smw);
                       if (error == 0)
                               smw->smw_tickler = l->l_proc->p_pid;
               } else
                       error = ESRCH;
               mutex_exit(&sysmon_wdog_mtx);
               break;

       case WDOGIOC_GTICKLER:
               if ((smw = sysmon_armed_wdog) != NULL)
                       *(pid_t *)data = smw->smw_tickler;
               else
                       error = ESRCH;
               break;

       case WDOGIOC_GWDOGS:
           {
               struct wdog_conf *wc = (void *) data;
               char *cp;
               int i;

               mutex_enter(&sysmon_wdog_list_mtx);
               if (wc->wc_names == NULL)
                       wc->wc_count = sysmon_wdog_count;
               else {
                       for (i = 0, cp = wc->wc_names,
                              smw = LIST_FIRST(&sysmon_wdog_list);
                            i < sysmon_wdog_count && smw != NULL && error == 0;
                            i++, cp += WDOG_NAMESIZE,
                              smw = LIST_NEXT(smw, smw_list))
                               error = copyout(smw->smw_name, cp,
                                   strlen(smw->smw_name) + 1);
                       wc->wc_count = i;
               }
               mutex_exit(&sysmon_wdog_list_mtx);
               break;
           }

       default:
               error = ENOTTY;
       }

       return error;
}

/*
* sysmon_wdog_register:
*
*      Register a watchdog device.
*/
int
sysmon_wdog_register(struct sysmon_wdog *smw)
{
       struct sysmon_wdog *lsmw;
       int error = 0;

       (void)RUN_ONCE(&once_wdog, wdog_preinit);

       mutex_enter(&sysmon_wdog_list_mtx);

       LIST_FOREACH(lsmw, &sysmon_wdog_list, smw_list) {
               if (strcmp(lsmw->smw_name, smw->smw_name) == 0) {
                       error = EEXIST;
                       goto out;
               }
       }

       smw->smw_mode = WDOG_MODE_DISARMED;
       smw->smw_tickler = (pid_t) -1;
       smw->smw_refcnt = 0;
       sysmon_wdog_count++;
       LIST_INSERT_HEAD(&sysmon_wdog_list, smw, smw_list);

out:
       mutex_exit(&sysmon_wdog_list_mtx);
       return error;
}

/*
* sysmon_wdog_unregister:
*
*      Unregister a watchdog device.
*/
int
sysmon_wdog_unregister(struct sysmon_wdog *smw)
{
       int rc = 0;

       mutex_enter(&sysmon_wdog_list_mtx);
       while (smw->smw_refcnt > 0 && rc == 0) {
               aprint_debug("%s: %d users remain\n", smw->smw_name,
                   smw->smw_refcnt);
               rc = cv_wait_sig(&sysmon_wdog_cv, &sysmon_wdog_list_mtx);
       }
       if (rc == 0) {
               sysmon_wdog_count--;
               LIST_REMOVE(smw, smw_list);
       }
       mutex_exit(&sysmon_wdog_list_mtx);
       return rc;
}

/*
* sysmon_wdog_critpoll:
*
*      Perform critical operations during long polling periods
*/
void
sysmon_wdog_critpoll(void *arg)
{
       struct sysmon_wdog *smw = sysmon_armed_wdog;

       if (smw == NULL)
               return;

       if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE) {
               if ((*smw->smw_tickle)(smw) != 0) {
                       printf("WARNING: KERNEL TICKLE OF WATCHDOG %s "
                           "FAILED!\n", smw->smw_name);
               }
       }
}

/*
* sysmon_wdog_find:
*
*      Find a watchdog device.  We increase the reference
*      count on a match.
*/
struct sysmon_wdog *
sysmon_wdog_find(const char *name)
{
       struct sysmon_wdog *smw;

       mutex_enter(&sysmon_wdog_list_mtx);

       LIST_FOREACH(smw, &sysmon_wdog_list, smw_list) {
               if (strcmp(smw->smw_name, name) == 0)
                       break;
       }

       if (smw != NULL)
               smw->smw_refcnt++;

       mutex_exit(&sysmon_wdog_list_mtx);
       return smw;
}

/*
* sysmon_wdog_release:
*
*      Release a watchdog device.
*/
void
sysmon_wdog_release(struct sysmon_wdog *smw)
{

       mutex_enter(&sysmon_wdog_list_mtx);
       KASSERT(smw->smw_refcnt != 0);
       smw->smw_refcnt--;
       cv_signal(&sysmon_wdog_cv);
       mutex_exit(&sysmon_wdog_list_mtx);
}

void
sysmon_wdog_ref(struct sysmon_wdog *smw)
{
       mutex_enter(&sysmon_wdog_list_mtx);
       smw->smw_refcnt++;
       mutex_exit(&sysmon_wdog_list_mtx);
}

/*
* sysmon_wdog_setmode:
*
*      Set the mode of a watchdog device.
*/
int
sysmon_wdog_setmode(struct sysmon_wdog *smw, int mode, u_int period)
{
       u_int operiod = smw->smw_period;
       int omode = smw->smw_mode;
       int error = 0;

       smw->smw_period = period;
       smw->smw_mode = mode;

       switch (mode & WDOG_MODE_MASK) {
       case WDOG_MODE_DISARMED:
               if (smw != sysmon_armed_wdog) {
                       error = EINVAL;
                       goto out;
               }
               break;

       case WDOG_MODE_KTICKLE:
       case WDOG_MODE_UTICKLE:
       case WDOG_MODE_ETICKLE:
               if (sysmon_armed_wdog != NULL) {
                       error = EBUSY;
                       goto out;
               }
               break;

       default:
               error = EINVAL;
               goto out;
       }

       error = (*smw->smw_setmode)(smw);

out:
       if (error) {
               smw->smw_period = operiod;
               smw->smw_mode = omode;
       } else {
               if ((mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) {
                       sysmon_armed_wdog = NULL;
                       smw->smw_tickler = (pid_t) -1;
                       sysmon_wdog_release(smw);
                       if ((omode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE)
                               callout_stop(&sysmon_wdog_callout);
               } else {
                       sysmon_armed_wdog = smw;
                       sysmon_wdog_ref(smw);
                       if ((mode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE) {
                               callout_reset(&sysmon_wdog_callout,
                                   WDOG_PERIOD_TO_TICKS(smw->smw_period) / 2,
                                   sysmon_wdog_ktickle, NULL);
                       }
               }
       }
       return error;
}

/*
* sysmon_wdog_ktickle:
*
*      Kernel watchdog tickle routine.
*/
void
sysmon_wdog_ktickle(void *arg)
{
       struct sysmon_wdog *smw;

       mutex_enter(&sysmon_wdog_mtx);
       if ((smw = sysmon_armed_wdog) != NULL) {
               if ((*smw->smw_tickle)(smw) != 0) {
                       printf("WARNING: KERNEL TICKLE OF WATCHDOG %s "
                           "FAILED!\n", smw->smw_name);
                       /*
                        * ...we will probably reboot soon.
                        */
               }
               callout_reset(&sysmon_wdog_callout,
                   WDOG_PERIOD_TO_TICKS(smw->smw_period) / 2,
                   sysmon_wdog_ktickle, NULL);
       }
       mutex_exit(&sysmon_wdog_mtx);
}

/*
* sysmon_wdog_shutdown:
*
*      Perform shutdown-time operations.
*/
void
sysmon_wdog_shutdown(void *arg)
{
       struct sysmon_wdog *smw;

       /*
        * XXX Locking here?  I don't think it's necessary.
        */

       if ((smw = sysmon_armed_wdog) != NULL) {
               if (sysmon_wdog_setmode(smw, WDOG_MODE_DISARMED,
                   smw->smw_period))
                       printf("WARNING: FAILED TO SHUTDOWN WATCHDOG %s!\n",
                           smw->smw_name);
       }
}

static int
sysmon_wdog_modcmd(modcmd_t cmd, void *arg)
{
       int ret;

       switch (cmd) {
       case MODULE_CMD_INIT:
               ret = sysmon_wdog_init();
               break;
       case MODULE_CMD_FINI:
               ret = sysmon_wdog_fini();
               break;
       case MODULE_CMD_STAT:
       default:
               ret = ENOTTY;
       }

       return ret;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.