Add a watchog timer framework to the system monitor.
This commit is contained in:
thorpej
parent
6ba1a794ad
commit
c48d521bdb
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: sysmon.c,v 1.2 2000/06/28 06:51:17 thorpej Exp $ */
|
||||
/* $NetBSD: sysmon.c,v 1.3 2000/11/04 18:37:19 thorpej Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 2000 Zembu Labs, Inc.
|
||||
|
|
@ -37,11 +37,9 @@
|
|||
* Clearing house for system monitoring hardware. This pseudo-device
|
||||
* is a place where hardware monitors such as the LM78 and VIA 82C686A
|
||||
* (or even ACPI, eventually) can register themselves to provide
|
||||
* backplane fan and temperature information, etc.
|
||||
*
|
||||
* Eventually, we will also provide a way for a hardware watchdog timer
|
||||
* to hook itself up here (with an option to fall back on a software
|
||||
* watchdog timer if hardware is not available).
|
||||
* backplane fan and temperature information, etc. It also provides
|
||||
* a place to register watchdog timers, and provides an abstract
|
||||
* interface to them.
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
|
|
@ -49,6 +47,10 @@
|
|||
#include <sys/errno.h>
|
||||
#include <sys/fcntl.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/callout.h>
|
||||
#include <sys/kernel.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/proc.h>
|
||||
|
||||
#include <dev/sysmon/sysmonvar.h>
|
||||
|
||||
|
|
@ -57,33 +59,68 @@
|
|||
*/
|
||||
#define SYSMON_ENVSYS_VERSION (1 * 1000)
|
||||
|
||||
struct lock sysmon_lock;
|
||||
struct lock sysmon_envsys_lock;
|
||||
|
||||
LIST_HEAD(, sysmon_envsys) sysmon_envsys_list;
|
||||
LIST_HEAD(, sysmon_envsys) sysmon_envsys_list =
|
||||
LIST_HEAD_INITIALIZER(&sysmon_envsys_list);
|
||||
struct simplelock sysmon_envsys_list_slock = SIMPLELOCK_INITIALIZER;
|
||||
u_int sysmon_envsys_next_sensor_index;
|
||||
|
||||
int sysmon_initialized;
|
||||
struct simplelock sysmon_initialized_slock = SIMPLELOCK_INITIALIZER;
|
||||
int sysmon_envsys_initialized;
|
||||
struct simplelock sysmon_envsys_initialized_slock = SIMPLELOCK_INITIALIZER;
|
||||
|
||||
cdev_decl(sysmon);
|
||||
|
||||
void sysmon_init(void);
|
||||
void sysmon_envsys_init(void);
|
||||
|
||||
int sysmonioctl_envsys(dev_t, u_long, caddr_t, int, struct proc *);
|
||||
int sysmonioctl_wdog(dev_t, u_long, caddr_t, int, struct proc *);
|
||||
|
||||
struct sysmon_envsys *sysmon_envsys_find(u_int);
|
||||
void sysmon_envsys_release(struct sysmon_envsys *);
|
||||
|
||||
LIST_HEAD(, sysmon_wdog) sysmon_wdog_list =
|
||||
LIST_HEAD_INITIALIZER(&sysmon_wdog_list);
|
||||
int sysmon_wdog_count;
|
||||
struct simplelock sysmon_wdog_list_slock = SIMPLELOCK_INITIALIZER;
|
||||
|
||||
struct simplelock sysmon_wdog_slock = SIMPLELOCK_INITIALIZER;
|
||||
struct sysmon_wdog *sysmon_armed_wdog;
|
||||
struct callout sysmon_wdog_callout = CALLOUT_INITIALIZER;
|
||||
void *sysmon_wdog_sdhook;
|
||||
|
||||
#define SYSMON_WDOG_LOCK(s) \
|
||||
do { \
|
||||
s = splsoftclock(); \
|
||||
simple_lock(&sysmon_wdog_slock); \
|
||||
} while (0)
|
||||
|
||||
#define SYSMON_WDOG_UNLOCK(s) \
|
||||
do { \
|
||||
simple_unlock(&sysmon_wdog_slock); \
|
||||
splx(s); \
|
||||
} while (0)
|
||||
|
||||
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_shutdown(void *);
|
||||
|
||||
#define SYSMON_MINOR_ENVSYS 0
|
||||
#define SYSMON_MINOR_WDOG 1
|
||||
|
||||
/*
|
||||
* sysmon_init:
|
||||
* sysmon_envsys_init:
|
||||
*
|
||||
* Initialize the system monitor.
|
||||
*/
|
||||
void
|
||||
sysmon_init(void)
|
||||
sysmon_envsys_init(void)
|
||||
{
|
||||
|
||||
lockinit(&sysmon_lock, PWAIT|PCATCH, "sysmon", 0, 0);
|
||||
sysmon_initialized = 1;
|
||||
lockinit(&sysmon_envsys_lock, PWAIT|PCATCH, "smenv", 0, 0);
|
||||
sysmon_envsys_initialized = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -94,15 +131,35 @@ sysmon_init(void)
|
|||
int
|
||||
sysmonopen(dev_t dev, int flag, int mode, struct proc *p)
|
||||
{
|
||||
int error;
|
||||
int error = 0;
|
||||
|
||||
simple_lock(&sysmon_initialized_slock);
|
||||
if (sysmon_initialized == 0)
|
||||
sysmon_init();
|
||||
switch (minor(dev)) {
|
||||
case SYSMON_MINOR_ENVSYS:
|
||||
simple_lock(&sysmon_envsys_initialized_slock);
|
||||
if (sysmon_envsys_initialized == 0)
|
||||
sysmon_envsys_init();
|
||||
|
||||
error = lockmgr(&sysmon_lock,
|
||||
LK_EXCLUSIVE | LK_INTERLOCK |
|
||||
((flag & O_NONBLOCK) ? LK_NOWAIT : 0), &sysmon_initialized_slock);
|
||||
error = lockmgr(&sysmon_envsys_lock,
|
||||
LK_EXCLUSIVE | LK_INTERLOCK |
|
||||
((flag & O_NONBLOCK) ? LK_NOWAIT : 0),
|
||||
&sysmon_envsys_initialized_slock);
|
||||
break;
|
||||
|
||||
case SYSMON_MINOR_WDOG:
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
if (sysmon_wdog_sdhook == NULL) {
|
||||
sysmon_wdog_sdhook =
|
||||
shutdownhook_establish(sysmon_wdog_shutdown, NULL);
|
||||
if (sysmon_wdog_sdhook == NULL)
|
||||
printf("WARNING: unable to register watchdog "
|
||||
"shutdown hook\n");
|
||||
}
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
break;
|
||||
|
||||
default:
|
||||
error = ENODEV;
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
|
@ -115,9 +172,49 @@ sysmonopen(dev_t dev, int flag, int mode, struct proc *p)
|
|||
int
|
||||
sysmonclose(dev_t dev, int flag, int mode, struct proc *p)
|
||||
{
|
||||
int error = 0;
|
||||
|
||||
(void) lockmgr(&sysmon_lock, LK_RELEASE, NULL);
|
||||
return (0);
|
||||
switch (minor(dev)) {
|
||||
case SYSMON_MINOR_ENVSYS:
|
||||
(void) lockmgr(&sysmon_envsys_lock, LK_RELEASE, NULL);
|
||||
break;
|
||||
|
||||
case SYSMON_MINOR_WDOG:
|
||||
{
|
||||
struct sysmon_wdog *smw;
|
||||
int omode, s;
|
||||
|
||||
/*
|
||||
* 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?
|
||||
*/
|
||||
SYSMON_WDOG_LOCK(s);
|
||||
if ((smw = sysmon_armed_wdog) != NULL) {
|
||||
if ((omode = smw->smw_mode) == 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.
|
||||
*/
|
||||
}
|
||||
}
|
||||
}
|
||||
SYSMON_WDOG_UNLOCK(s);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
error = ENODEV;
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -127,6 +224,33 @@ sysmonclose(dev_t dev, int flag, int mode, struct proc *p)
|
|||
*/
|
||||
int
|
||||
sysmonioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
|
||||
{
|
||||
int error;
|
||||
|
||||
switch (minor(dev)) {
|
||||
case SYSMON_MINOR_ENVSYS:
|
||||
error = sysmonioctl_envsys(dev, cmd, data, flag, p);
|
||||
break;
|
||||
|
||||
case SYSMON_MINOR_WDOG:
|
||||
error = sysmonioctl_wdog(dev, cmd, data, flag, p);
|
||||
break;
|
||||
|
||||
default:
|
||||
error = ENODEV;
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmonioctl_envsys:
|
||||
*
|
||||
* Perform an envsys control request.
|
||||
*/
|
||||
int
|
||||
sysmonioctl_envsys(dev_t dev, u_long cmd, caddr_t data, int flag,
|
||||
struct proc *p)
|
||||
{
|
||||
struct sysmon_envsys *sme;
|
||||
int error = 0;
|
||||
|
|
@ -227,6 +351,129 @@ sysmonioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
|
|||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmonioctl_wdog:
|
||||
*
|
||||
* Perform a watchdog control request.
|
||||
*/
|
||||
int
|
||||
sysmonioctl_wdog(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
|
||||
{
|
||||
struct sysmon_wdog *smw;
|
||||
int s, 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 {
|
||||
SYSMON_WDOG_LOCK(s);
|
||||
error = sysmon_wdog_setmode(smw, wm->wm_mode,
|
||||
wm->wm_period);
|
||||
SYSMON_WDOG_UNLOCK(s);
|
||||
}
|
||||
|
||||
sysmon_wdog_release(smw);
|
||||
break;
|
||||
}
|
||||
|
||||
case WDOGIOC_WHICH:
|
||||
{
|
||||
struct wdog_mode *wm = (void *) data;
|
||||
|
||||
SYSMON_WDOG_LOCK(s);
|
||||
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;
|
||||
SYSMON_WDOG_UNLOCK(s);
|
||||
break;
|
||||
}
|
||||
|
||||
case WDOGIOC_TICKLE:
|
||||
if ((flag & FWRITE) == 0) {
|
||||
error = EPERM;
|
||||
break;
|
||||
}
|
||||
|
||||
SYSMON_WDOG_LOCK(s);
|
||||
if ((smw = sysmon_armed_wdog) != NULL) {
|
||||
error = (*smw->smw_tickle)(smw);
|
||||
if (error == 0)
|
||||
smw->smw_tickler = p->p_pid;
|
||||
} else
|
||||
error = ESRCH;
|
||||
SYSMON_WDOG_UNLOCK(s);
|
||||
break;
|
||||
|
||||
case WDOGIOC_GTICKLER:
|
||||
*(pid_t *)data = smw->smw_tickler;
|
||||
break;
|
||||
|
||||
case WDOGIOC_GWDOGS:
|
||||
{
|
||||
struct wdog_conf *wc = (void *) data;
|
||||
char *cp;
|
||||
int i;
|
||||
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
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;
|
||||
}
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
error = ENOTTY;
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmon_envsys_register:
|
||||
*
|
||||
|
|
@ -309,3 +556,201 @@ sysmon_envsys_release(struct sysmon_envsys *sme)
|
|||
|
||||
simple_unlock(&sysmon_envsys_list_slock);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmon_wdog_register:
|
||||
*
|
||||
* Register a watchdog device.
|
||||
*/
|
||||
int
|
||||
sysmon_wdog_register(struct sysmon_wdog *smw)
|
||||
{
|
||||
struct sysmon_wdog *lsmw;
|
||||
int error = 0;
|
||||
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
|
||||
for (lsmw = LIST_FIRST(&sysmon_wdog_list); lsmw != NULL;
|
||||
lsmw = LIST_NEXT(lsmw, 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:
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmon_wdog_unregister:
|
||||
*
|
||||
* Unregister a watchdog device.
|
||||
*/
|
||||
void
|
||||
sysmon_wdog_unregister(struct sysmon_wdog *smw)
|
||||
{
|
||||
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
sysmon_wdog_count--;
|
||||
LIST_REMOVE(smw, smw_list);
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
}
|
||||
|
||||
/*
|
||||
* 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;
|
||||
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
|
||||
for (smw = LIST_FIRST(&sysmon_wdog_list); smw != NULL;
|
||||
smw = LIST_NEXT(smw, smw_list)) {
|
||||
if (strcmp(smw->smw_name, name) == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
if (smw != NULL)
|
||||
smw->smw_refcnt++;
|
||||
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
return (smw);
|
||||
}
|
||||
|
||||
/*
|
||||
* sysmon_wdog_release:
|
||||
*
|
||||
* Release a watchdog device.
|
||||
*/
|
||||
void
|
||||
sysmon_wdog_release(struct sysmon_wdog *smw)
|
||||
{
|
||||
|
||||
simple_lock(&sysmon_wdog_list_slock);
|
||||
KASSERT(smw->smw_refcnt != 0);
|
||||
smw->smw_refcnt--;
|
||||
simple_unlock(&sysmon_wdog_list_slock);
|
||||
}
|
||||
|
||||
/*
|
||||
* 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:
|
||||
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) {
|
||||
smw->smw_tickler = (pid_t) -1;
|
||||
smw->smw_refcnt--;
|
||||
if ((omode & WDOG_MODE_MASK) == WDOG_MODE_KTICKLE)
|
||||
callout_stop(&sysmon_wdog_callout);
|
||||
} else {
|
||||
sysmon_armed_wdog = smw;
|
||||
smw->smw_refcnt++;
|
||||
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;
|
||||
int s;
|
||||
|
||||
SYSMON_WDOG_LOCK(s);
|
||||
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);
|
||||
}
|
||||
SYSMON_WDOG_UNLOCK(s);
|
||||
}
|
||||
|
||||
/*
|
||||
* 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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $NetBSD: sysmonvar.h,v 1.1 2000/06/24 00:37:20 thorpej Exp $ */
|
||||
/* $NetBSD: sysmonvar.h,v 1.2 2000/11/04 18:37:19 thorpej Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 2000 Zembu Labs, Inc.
|
||||
|
|
@ -37,6 +37,7 @@
|
|||
#define _DEV_SYSMON_SYSMONVAR_H_
|
||||
|
||||
#include <sys/envsys.h>
|
||||
#include <sys/wdog.h>
|
||||
#include <sys/queue.h>
|
||||
|
||||
struct sysmon_envsys {
|
||||
|
|
@ -59,7 +60,24 @@ struct sysmon_envsys {
|
|||
|
||||
#define SME_SENSOR_IDX(sme, idx) ((idx) - (sme)->sme_fsensor)
|
||||
|
||||
struct sysmon_wdog {
|
||||
const char *smw_name; /* watchdog device name */
|
||||
|
||||
LIST_ENTRY(sysmon_wdog) smw_list;
|
||||
|
||||
void *smw_cookie; /* for watchdog back-end */
|
||||
int (*smw_setmode)(struct sysmon_wdog *);
|
||||
int (*smw_tickle)(struct sysmon_wdog *);
|
||||
u_int smw_period; /* timer period (in seconds) */
|
||||
int smw_mode; /* timer mode */
|
||||
u_int smw_refcnt; /* references */
|
||||
pid_t smw_tickler; /* last process to tickle */
|
||||
};
|
||||
|
||||
int sysmon_envsys_register(struct sysmon_envsys *);
|
||||
void sysmon_envsys_unregister(struct sysmon_envsys *);
|
||||
|
||||
int sysmon_wdog_register(struct sysmon_wdog *);
|
||||
void sysmon_wdog_unregister(struct sysmon_wdog *);
|
||||
|
||||
#endif /* _DEV_SYSMON_SYSMONVAR_H_ */
|
||||
|
|
|
|||
Loading…
Reference in New Issue