xref: /src/sbin/wdogctl/wdogctl.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 (at) 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);
}