452 lines
10 KiB
C
452 lines
10 KiB
C
/* $NetBSD: wdogctl.c,v 1.17 2006/08/13 23:24:53 wiz Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 2000 Zembu Labs, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Author: Jason R. Thorpe <thorpej@zembu.com>
|
|
*
|
|
* 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.
|
|
*/
|
|
#include <sys/cdefs.h>
|
|
|
|
#ifndef lint
|
|
__RCSID("$NetBSD: wdogctl.c,v 1.17 2006/08/13 23:24:53 wiz Exp $");
|
|
#endif
|
|
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/wdog.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
#include <signal.h>
|
|
#include <syslog.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
|
|
#define _PATH_WATCHDOG "/dev/watchdog"
|
|
|
|
int main(int, char *[]);
|
|
void enable_kernel(const char *, u_int);
|
|
void enable_user(const char *, u_int, int);
|
|
void enable_ext(const char *, u_int);
|
|
void tickle_ext(void);
|
|
void disable(void);
|
|
void prep_wmode(struct wdog_mode *, int, const char *, u_int);
|
|
void list_timers(void);
|
|
void usage(void);
|
|
|
|
int Aflag;
|
|
|
|
/* Caution -- ordered list; entries >= CMD_EXT_TICKLE set timers */
|
|
enum cmd {
|
|
CMD_NONE, /* No verb given */
|
|
CMD_DISABLE,
|
|
CMD_DOTICKLE,
|
|
CMD_EXT_TICKLE,
|
|
CMD_KERN_TICKLE,
|
|
CMD_NOCANCEL_TICKLE,
|
|
CMD_USER_TICKLE
|
|
};
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
enum cmd command = CMD_NONE;
|
|
int period_flag = 0;
|
|
int ch;
|
|
u_int period = WDOG_PERIOD_DEFAULT;
|
|
|
|
while ((ch = getopt(argc, argv, "Adekp:utx")) != -1) {
|
|
switch (ch) {
|
|
case 'A':
|
|
Aflag = 1;
|
|
break;
|
|
|
|
case 'd':
|
|
if (command != CMD_NONE)
|
|
usage();
|
|
command = CMD_DISABLE;
|
|
break;
|
|
|
|
case 'e':
|
|
if (command != CMD_NONE)
|
|
usage();
|
|
command = CMD_EXT_TICKLE;
|
|
break;
|
|
|
|
case 'k':
|
|
if (command != CMD_NONE)
|
|
usage();
|
|
command = CMD_KERN_TICKLE;
|
|
break;
|
|
|
|
case 't':
|
|
if (command != CMD_NONE)
|
|
usage();
|
|
command = CMD_DOTICKLE;
|
|
break;
|
|
|
|
case 'p':
|
|
period_flag = 1;
|
|
period = atoi(optarg);
|
|
if (period == -1)
|
|
usage();
|
|
break;
|
|
|
|
case 'x':
|
|
case 'u':
|
|
if (command != CMD_NONE)
|
|
usage();
|
|
command =
|
|
(ch == 'u') ? CMD_USER_TICKLE : CMD_NOCANCEL_TICKLE;
|
|
break;
|
|
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (command < CMD_EXT_TICKLE) {
|
|
if (Aflag || period_flag)
|
|
usage();
|
|
if (argc != 0)
|
|
usage();
|
|
} else if (argc != 1)
|
|
usage();
|
|
|
|
switch (command) {
|
|
case CMD_NONE:
|
|
list_timers();
|
|
break;
|
|
case CMD_DISABLE:
|
|
disable();
|
|
break;
|
|
case CMD_DOTICKLE:
|
|
tickle_ext();
|
|
break;
|
|
case CMD_EXT_TICKLE:
|
|
enable_ext(argv[0], period);
|
|
break;
|
|
case CMD_KERN_TICKLE:
|
|
enable_kernel(argv[0], period);
|
|
break;
|
|
case CMD_NOCANCEL_TICKLE:
|
|
case CMD_USER_TICKLE:
|
|
enable_user(argv[0], period, command == CMD_USER_TICKLE);
|
|
break;
|
|
}
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
void
|
|
prep_wmode(struct wdog_mode *wp, int mode, const char *name, u_int period)
|
|
{
|
|
if (strlen(name) >= WDOG_NAMESIZE)
|
|
errx(EXIT_FAILURE, "invalid watchdog timer name: %s", name);
|
|
|
|
strlcpy(wp->wm_name, name, sizeof(wp->wm_name));
|
|
wp->wm_mode = mode;
|
|
wp->wm_period = period;
|
|
if (Aflag)
|
|
wp->wm_mode |= WDOG_FEATURE_ALARM;
|
|
}
|
|
|
|
void
|
|
enable_kernel(const char *name, u_int period)
|
|
{
|
|
struct wdog_mode wm;
|
|
int fd;
|
|
|
|
prep_wmode(&wm, WDOG_MODE_KTICKLE, name, period);
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDWR, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
|
|
if (ioctl(fd, WDOGIOC_SMODE, &wm) == -1)
|
|
err(EXIT_FAILURE, "WDOGIOC_SMODE");
|
|
}
|
|
|
|
void
|
|
enable_ext(const char *name, u_int period)
|
|
{
|
|
struct wdog_mode wm;
|
|
int fd;
|
|
|
|
prep_wmode(&wm, WDOG_MODE_ETICKLE, name, period);
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDWR, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
if (ioctl(fd, WDOGIOC_SMODE, &wm) == -1) {
|
|
err(EXIT_FAILURE, "WDOGIOC_SMODE");
|
|
}
|
|
if (ioctl(fd, WDOGIOC_TICKLE) == -1)
|
|
syslog(LOG_EMERG, "unable to tickle watchdog timer %s: %m",
|
|
wm.wm_name);
|
|
return;
|
|
}
|
|
|
|
void
|
|
enable_user(const char *name, u_int period, int cancel_on_close)
|
|
{
|
|
struct wdog_mode wm;
|
|
struct timespec ts;
|
|
pid_t tickler;
|
|
int fd, rv;
|
|
|
|
prep_wmode(&wm,
|
|
(cancel_on_close) ? WDOG_MODE_UTICKLE : WDOG_MODE_ETICKLE, name,
|
|
period);
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDWR, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
|
|
/* ...so we can log failures to tickle the timer. */
|
|
openlog("wdogctl", LOG_PERROR|LOG_PID, LOG_DAEMON);
|
|
|
|
/*
|
|
* We fork a child process which detaches from the controlling
|
|
* terminal once the timer is armed, and tickles the timer
|
|
* until we send it a SIGTERM.
|
|
*/
|
|
tickler = fork();
|
|
if (tickler == -1)
|
|
err(EXIT_FAILURE, "unable to fork tickler process");
|
|
else if (tickler != 0) {
|
|
if (ioctl(fd, WDOGIOC_SMODE, &wm) == -1) {
|
|
(void)kill(tickler, SIGTERM);
|
|
err(EXIT_FAILURE, "WDOGIOC_SMODE");
|
|
}
|
|
(void)close(fd);
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Wait for the watchdog to be armed. When it is, loop,
|
|
* tickling the timer, then waiting 1/2 the period before
|
|
* doing it again.
|
|
*
|
|
* If the parent fails to enable the watchdog, it will kill
|
|
* us.
|
|
*/
|
|
do {
|
|
rv = ioctl(fd, WDOGIOC_WHICH, &wm);
|
|
} while (rv == -1);
|
|
|
|
if (ioctl(fd, WDOGIOC_TICKLE) == -1)
|
|
syslog(LOG_EMERG, "unable to tickle watchdog timer %s: %m",
|
|
wm.wm_name);
|
|
|
|
/*
|
|
* Now detach from the controlling terminal, and just run
|
|
* in the background. The kernel will keep track of who
|
|
* we are, each time we tickle the timer.
|
|
*/
|
|
if (daemon(0, 0) == -1) {
|
|
/*
|
|
* We weren't able to go into the background. When
|
|
* we exit, the kernel will disable the watchdog so
|
|
* that the system won't die.
|
|
*/
|
|
err(EXIT_FAILURE, "unable to detach from terminal");
|
|
}
|
|
|
|
if (ioctl(fd, WDOGIOC_TICKLE) == -1)
|
|
syslog(LOG_EMERG, "unable to tickle watchdog timer %s: %m",
|
|
wm.wm_name);
|
|
|
|
for (;;) {
|
|
ts.tv_sec = wm.wm_period / 2;
|
|
ts.tv_nsec = 0;
|
|
(void)nanosleep(&ts, NULL);
|
|
|
|
if (ioctl(fd, WDOGIOC_TICKLE) == -1)
|
|
syslog(LOG_EMERG,
|
|
"unable to tickle watchdog timer %s: %m",
|
|
wm.wm_name);
|
|
}
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
void
|
|
tickle_ext()
|
|
{
|
|
int fd;
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDWR, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
if (ioctl(fd, WDOGIOC_TICKLE) == -1)
|
|
fprintf(stderr, "Cannot tickle timer\n");
|
|
}
|
|
|
|
void
|
|
disable(void)
|
|
{
|
|
struct wdog_mode wm;
|
|
pid_t tickler;
|
|
int fd, mode;
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDWR, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
|
|
if (ioctl(fd, WDOGIOC_WHICH, &wm) == -1) {
|
|
printf("No watchdog timer running.\n");
|
|
return;
|
|
}
|
|
mode = wm.wm_mode & WDOG_MODE_MASK;
|
|
|
|
/*
|
|
* If the timer is running in UTICKLE mode, we need
|
|
* to kill the wdogctl(8) process that is tickling
|
|
* the timer.
|
|
*/
|
|
if (mode == WDOG_MODE_UTICKLE) {
|
|
if (ioctl(fd, WDOGIOC_GTICKLER, &tickler) == -1)
|
|
err(EXIT_FAILURE, "WDOGIOC_GTICKLER");
|
|
(void)close(fd);
|
|
(void)kill(tickler, SIGTERM);
|
|
} else {
|
|
wm.wm_mode = WDOG_MODE_DISARMED;
|
|
if (ioctl(fd, WDOGIOC_SMODE, &wm) == -1) {
|
|
err(EXIT_FAILURE, "unable to disarm watchdog %s",
|
|
wm.wm_name);
|
|
}
|
|
(void)close(fd);
|
|
}
|
|
}
|
|
|
|
void
|
|
list_timers(void)
|
|
{
|
|
struct wdog_conf wc;
|
|
struct wdog_mode wm;
|
|
char *buf, *cp;
|
|
int fd, count, i, mode;
|
|
pid_t tickler;
|
|
|
|
fd = open(_PATH_WATCHDOG, O_RDONLY, 0644);
|
|
if (fd == -1)
|
|
err(EXIT_FAILURE, "open %s", _PATH_WATCHDOG);
|
|
|
|
wc.wc_names = NULL;
|
|
wc.wc_count = 0;
|
|
|
|
if (ioctl(fd, WDOGIOC_GWDOGS, &wc) == -1)
|
|
err(EXIT_FAILURE, "ioctl WDOGIOC_GWDOGS for count");
|
|
|
|
count = wc.wc_count;
|
|
if (count == 0) {
|
|
printf("No watchdog timers present.\n");
|
|
goto out;
|
|
}
|
|
|
|
buf = malloc(count * WDOG_NAMESIZE);
|
|
if (buf == NULL)
|
|
err(EXIT_FAILURE, "malloc %d byte for watchdog names",
|
|
count * WDOG_NAMESIZE);
|
|
|
|
wc.wc_names = buf;
|
|
if (ioctl(fd, WDOGIOC_GWDOGS, &wc) == -1)
|
|
err(EXIT_FAILURE, "ioctl WDOGIOC_GWDOGS for names");
|
|
|
|
count = wc.wc_count;
|
|
if (count == 0) {
|
|
printf("No watchdog timers present.\n");
|
|
free(buf);
|
|
goto out;
|
|
}
|
|
|
|
printf("Available watchdog timers:\n");
|
|
for (i = 0, cp = buf; i < count; i++, cp += WDOG_NAMESIZE) {
|
|
cp[WDOG_NAMESIZE - 1] = '\0';
|
|
strlcpy(wm.wm_name, cp, sizeof(wm.wm_name));
|
|
|
|
if (ioctl(fd, WDOGIOC_GMODE, &wm) == -1)
|
|
continue;
|
|
mode = wm.wm_mode & WDOG_MODE_MASK;
|
|
if (mode == WDOG_MODE_UTICKLE) {
|
|
if (ioctl(fd, WDOGIOC_GTICKLER, &tickler) == -1)
|
|
tickler = (pid_t) -1;
|
|
}
|
|
|
|
printf("\t%s, %u second period", cp, wm.wm_period);
|
|
if (mode != WDOG_MODE_DISARMED) {
|
|
switch(mode) {
|
|
case WDOG_MODE_KTICKLE:
|
|
printf(" [armed, kernel tickle");
|
|
break;
|
|
case WDOG_MODE_UTICKLE:
|
|
printf(" [armed, user tickle");
|
|
if (tickler != (pid_t) -1)
|
|
printf(", pid %d", tickler);
|
|
break;
|
|
case WDOG_MODE_ETICKLE:
|
|
printf(" [armed, external tickle");
|
|
break;
|
|
}
|
|
printf("]");
|
|
}
|
|
printf("\n");
|
|
}
|
|
out:
|
|
(void)close(fd);
|
|
}
|
|
|
|
void
|
|
usage(void)
|
|
{
|
|
|
|
fprintf(stderr, "usage: %s\n", getprogname());
|
|
fprintf(stderr, " %s -d\n", getprogname());
|
|
fprintf(stderr, " %s -e [-A] [-p seconds] timer\n",
|
|
getprogname());
|
|
fprintf(stderr, " %s -k [-A] [-p seconds] timer\n",
|
|
getprogname());
|
|
fprintf(stderr, " %s -t\n", getprogname());
|
|
fprintf(stderr, " %s -u [-A] [-p seconds] timer\n",
|
|
getprogname());
|
|
fprintf(stderr, " %s -x [-A] [-p seconds] timer\n",
|
|
getprogname());
|
|
|
|
exit(1);
|
|
}
|