xref: /netbsd-src/usr.sbin/powerd/powerd.c (revision 2bd8f802e402fd318180dfc11d6dd13f109f058b)

/*	$NetBSD: powerd.c,v 1.21 2023/08/03 08:03:19 mrg Exp $	*/

/*
 * Copyright (c) 2003 Wasabi Systems, Inc.
 * All rights reserved.
 *
 * Written by Jason R. Thorpe for Wasabi Systems, Inc.
 *
 * 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 for the NetBSD Project by
 *	Wasabi Systems, Inc.
 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
 *    or promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL WASABI SYSTEMS, INC
 * 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.
 */

/*
 * Power management daemon for sysmon.
 */

#define SYSLOG_NAMES

#include <sys/cdefs.h>
#include <sys/ioctl.h>
#include <sys/param.h>
#include <sys/event.h>
#include <sys/power.h>
#include <sys/wait.h>
#include <err.h>
#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>
#include <syslog.h>
#include <unistd.h>
#include <util.h>
#include <prop/proplib.h>
#include <stdarg.h>
#include <string.h>

#include "prog_ops.h"

int	debug, no_scripts;

static int kq;

#define	_PATH_POWERD_SCRIPTS	"/etc/powerd/scripts"

static void usage(void) __dead;
static void run_script(const char *[]);
static struct kevent *allocchange(void);
static int wait_for_events(struct kevent *, size_t);
static void dispatch_dev_power(struct kevent *);
static void dispatch_power_event_state_change(int, power_event_t *);
static void powerd_log(int, const char *, ...) __printflike(2, 3);

static const char *script_paths[] = {
	NULL,
	_PATH_POWERD_SCRIPTS
};

int
main(int argc, char *argv[])
{
	struct kevent *ev, events[16];
	struct power_type power_type;
	char *cp;
	int ch, fd;

	setprogname(*argv);

	if (prog_init && prog_init() == -1)
		err(1, "init failed");

	while ((ch = getopt(argc, argv, "dn")) != -1) {
		switch (ch) {
		case 'd':
			debug = 1;
			break;

		case 'n':
			no_scripts = 1;
			break;

		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	if (argc)
		usage();

	if (debug == 0) {
		(void)daemon(0, 0);

		openlog("powerd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);
		(void)pidfile(NULL);
	}

	if ((kq = prog_kqueue()) == -1) {
		powerd_log(LOG_ERR, "kqueue: %s", strerror(errno));
		exit(EX_OSERR);
	}

	if ((fd = prog_open(_PATH_POWER, O_RDONLY|O_NONBLOCK, 0600)) == -1) {
		powerd_log(LOG_ERR, "open %s: %s", _PATH_POWER,
		    strerror(errno));
		exit(EX_OSERR);
	}

	if (prog_fcntl(fd, F_SETFD, FD_CLOEXEC) == -1) {
		powerd_log(LOG_ERR, "Cannot set close on exec in power fd: %s",
		    strerror(errno));
		exit(EX_OSERR);
	}

	if (prog_ioctl(fd, POWER_IOC_GET_TYPE, &power_type) == -1) {
		powerd_log(LOG_ERR, "POWER_IOC_GET_TYPE: %s", strerror(errno));
		exit(EX_OSERR);
	}

	(void)asprintf(&cp, "%s/%s", _PATH_POWERD_SCRIPTS,
	    power_type.power_type);
	if (cp == NULL) {
		powerd_log(LOG_ERR, "allocating script path: %s",
		    strerror(errno));
		exit(EX_OSERR);
	}
	script_paths[0] = cp;

	ev = allocchange();
	EV_SET(ev, fd, EVFILT_READ, EV_ADD | EV_ENABLE,
	    0, 0, (intptr_t) dispatch_dev_power);

	for (;;) {
		void (*handler)(struct kevent *);
		int i, rv;

		rv = wait_for_events(events, __arraycount(events));
		for (i = 0; i < rv; i++) {
			handler = (void *) events[i].udata;
			(*handler)(&events[i]);
		}
	}
}

static void
usage(void)
{

	(void)fprintf(stderr, "usage: %s [-dn]\n", getprogname());
	exit(EX_USAGE);
}

static void
run_script(const char *argv[])
{
	char path[MAXPATHLEN+1];
	size_t i, j;

	for (i = 0; i < __arraycount(script_paths); i++) {
		(void)snprintf(path, sizeof(path), "%s/%s", script_paths[i],
		    argv[0]);
		if (access(path, R_OK|X_OK) == 0) {
			int status;
			pid_t pid;
			const char *orig_argv0 = argv[0];

			argv[0] = path;

			if (debug) {
				(void)fprintf(stderr, "%srunning script: %s",
				    no_scripts?"not ":"", argv[0]);
				for (j = 1; argv[j] != NULL; j++)
					(void)fprintf(stderr, " %s", argv[j]);
				(void)fprintf(stderr, "\n");
			}
			if (no_scripts != 0) {
				argv[0] = orig_argv0;
				return;
			}

			switch ((pid = vfork())) {
			case -1:
				powerd_log(LOG_ERR, "fork to run script: %s",
				    strerror(errno));
				argv[0] = orig_argv0;
				return;

			case 0:
				/* Child. */
				(void) execv(path, __UNCONST(argv));
				_exit(1);
				/* NOTREACHED */

			default:
				/* Parent. */
				if (waitpid(pid, &status, 0) == -1) {
					powerd_log(LOG_ERR,
					    "waitpid for %s: %s", path,
					    strerror(errno));
					break;
				}
				if (WIFEXITED(status) &&
				    WEXITSTATUS(status) != 0) {
					powerd_log(LOG_ERR,
					    "%s exited with status %d",
					    path, WEXITSTATUS(status));
				} else if (!WIFEXITED(status)) {
					powerd_log(LOG_ERR,
					    "%s terminated abnormally", path);
				}
				break;
			}
			argv[0] = orig_argv0;

			return;
		}
	}

	powerd_log(LOG_ERR, "no script for %s", argv[0]);
}

static struct kevent changebuf[8];
static size_t nchanges;

static struct kevent *
allocchange(void)
{

	if (nchanges == __arraycount(changebuf)) {
		(void)wait_for_events(NULL, 0);
		nchanges = 0;
	}

	return &changebuf[nchanges++];
}

static int
wait_for_events(struct kevent *events, size_t nevents)
{
	int rv;

	while ((rv = prog_kevent(kq, nchanges ? changebuf : NULL, nchanges,
	    events, nevents, NULL)) < 0) {
		nchanges = 0;
		if (errno != EINTR) {
			powerd_log(LOG_ERR, "kevent: %s", strerror(errno));
			exit(EX_OSERR);
		}
	}

	return rv;
}

static void
dispatch_dev_power(struct kevent *ev)
{
	power_event_t pev;
	int fd = ev->ident;

	if (debug)
		(void)fprintf(stderr, "%s: %" PRId64
		    " event%s available\n", __func__,
		    ev->data, ev->data > 1 ? "s" : "");

 again:
	if (prog_read(fd, &pev, sizeof(pev)) != sizeof(pev)) {
		if (errno == EWOULDBLOCK)
			return;
		powerd_log(LOG_ERR, "read of %s: %s", _PATH_POWER,
		    strerror(errno));
		exit(EX_OSERR);
	}

	if (debug)
		(void)fprintf(stderr, "%s: event type %d\n",
		    __func__, pev.pev_type);

	switch (pev.pev_type) {
	case POWER_EVENT_ENVSYS_STATE_CHANGE:
	case POWER_EVENT_SWITCH_STATE_CHANGE:
		dispatch_power_event_state_change(fd, &pev);
		break;
	default:
		powerd_log(LOG_INFO, "unknown %s event type: %d",
		    _PATH_POWER, pev.pev_type);
	}

	goto again;
}

static void
dispatch_power_event_state_change(int fd, power_event_t *pev)
{
	prop_dictionary_t dict;
	const char *argv[6];
	char *buf = NULL;
	int error;

	error = prop_dictionary_recv_ioctl(fd, POWER_EVENT_RECVDICT, &dict);
	if (error) {
		if (debug)
			printf("%s: prop_dictionary_recv_ioctl error=%d\n",
			    __func__, error);
		return;
	}

	if (debug) {
		buf = prop_dictionary_externalize(dict);
		printf("%s", buf);
		free(buf);
	}

	/* First three arguments are not optional. */
	if (!prop_dictionary_get_string(dict, "powerd-script-name", &argv[0])) {
		powerd_log(LOG_ERR, "dict does not have powerd-script-name");
		return;
	}
	if (!prop_dictionary_get_string(dict, "driver-name", &argv[1])) {
		powerd_log(LOG_ERR, "dict does not have driver-name");
		return;
	}
	if (!prop_dictionary_get_string(dict, "powerd-event-name", &argv[2])) {
		powerd_log(LOG_ERR, "dict does not have powerd-event-name");
		return;
	}

	/* These arguments are optional. */
	if (!prop_dictionary_get_string(dict, "sensor-name", &argv[3]))
		argv[3] = NULL;
	if (!prop_dictionary_get_string(dict, "state-description", &argv[4]))
		argv[4] = NULL;

	argv[5] = NULL;

	run_script(argv);
}

static void
powerd_log(int pri, const char *msg, ...)
{
	va_list arglist;
	unsigned int i;

	va_start(arglist, msg);
	if (debug == 0)
		vsyslog(pri, msg, arglist);
	else {
		for (i = 0; i < __arraycount(prioritynames); i++)
			if (prioritynames[i].c_val == pri)
				break;
		fprintf(stderr, "%s: ",
		    (prioritynames[i].c_val == -1) ?
			    "UNKNOWN" : prioritynames[i].c_name);
		vfprintf(stderr, msg, arglist);
	}
	va_end(arglist);
}