xref: /dflybsd-src/usr.sbin/powerd/powerd.c (revision 2c3b1d1bc3a233e4bf80218452e719882a1bb011)

/*
 * Copyright (c) 2010,2016 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.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. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``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 THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS 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.
 */

/*
 * The powerd daemon :
 * - Monitor the cpu load and adjusts cpu and cpu power domain
 *   performance accordingly.
 * - Monitor battery life.  Alarm alerts and shutdown the machine
 *   if battery life goes low.
 */

#define _KERNEL_STRUCTURES
#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/kinfo.h>
#include <sys/queue.h>
#include <sys/soundcard.h>
#include <sys/sensors.h>
#include <sys/time.h>
#include <sys/cpumask.h>
#include <machine/cpufunc.h>
#include <err.h>
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <syslog.h>

#include "alert1.h"

#define MAXDOM		MAXCPU	/* worst case, 1 cpu per domain */

#define MAXFREQ		64
#define CST_STRLEN	16

#define NFREQ_MONPERF	0x0001
#define NFREQ_ADJPERF	0x0002
#define NFREQ_CPUTEMP	0x0004

#define NFREQ_ALL	(NFREQ_MONPERF | NFREQ_ADJPERF | NFREQ_CPUTEMP)

struct cpu_pwrdom {
	TAILQ_ENTRY(cpu_pwrdom)	dom_link;
	int			dom_id;
	int			dom_ncpus;
	cpumask_t		dom_cpumask;
};

struct cpu_state {
	double			cpu_qavg;
	double			cpu_uavg;	/* used for speeding up */
	double			cpu_davg;	/* used for slowing down */
	int			cpu_limit;
	int			cpu_count;
	char			cpu_name[8];
};

static void usage(void);
static void get_ncpus(void);
static void mon_cputemp(void);

/* usched cpumask */
static void get_uschedcpus(void);
static void set_uschedcpus(void);

/* perfbias(4) */
static int has_perfbias(void);
static void set_perfbias(int, int);

/* acpi(4) P-state */
static void acpi_getcpufreq_str(int, int *, int *);
static int acpi_getcpufreq_bin(int, int *, int *);
static void acpi_get_cpufreq(int, int *, int *);
static void acpi_set_cpufreq(int, int);
static int acpi_get_cpupwrdom(void);

/* mwait C-state hint */
static int probe_cstate(void);
static void set_cstate(int, int);

/* Performance monitoring */
static void init_perf(void);
static void mon_perf(double);
static void adj_perf(cpumask_t, cpumask_t);
static void adj_cpu_pwrdom(int, int);
static void adj_cpu_perf(int, int);
static void get_cputime(double);
static int get_nstate(struct cpu_state *, double);
static void add_spare_cpus(const cpumask_t, int);
static void restore_perf(void);
static void set_global_freq(int freq);

/* Battery monitoring */
static int has_battery(void);
static int mon_battery(void);
static void low_battery_alert(int);

/* Backlight */
static void restore_backlight(void);

/* Runtime states for performance monitoring */
static int global_pcpu_limit;
static struct cpu_state pcpu_state[MAXCPU];
static struct cpu_state global_cpu_state;
static cpumask_t cpu_used;		/* cpus w/ high perf */
static cpumask_t cpu_pwrdom_used;	/* cpu power domains w/ high perf */
static cpumask_t usched_cpu_used;	/* cpus for usched */

/* Constants */
static cpumask_t cpu_pwrdom_mask;	/* usable cpu power domains */
static int cpu2pwrdom[MAXCPU];		/* cpu to cpu power domain map */
static struct cpu_pwrdom *cpu_pwrdomain[MAXDOM];
static int NCpus;			/* # of cpus */
static char orig_global_cx[CST_STRLEN];
static char cpu_perf_cx[CST_STRLEN];
static int cpu_perf_cxlen;
static char cpu_idle_cx[CST_STRLEN];
static int cpu_idle_cxlen;
static int FreqAry[MAXFREQ];
static int NFreq;
static int NFreqChanged = NFREQ_ALL;
static int SavedPXGlobal;

static int DebugOpt;
static int TurboOpt = 1;
static int PowerFd;
static int Hysteresis = 10;	/* percentage */
static double TriggerUp = 0.25;	/* single-cpu load to force max freq */
static double TriggerDown;	/* load per cpu to force the min freq */
static int HasPerfbias = 0;
static int AdjustCpuFreq = 1;
static int AdjustCstate = 0;
static int HighestCpuFreq;
static int LowestCpuFreq;
static int AdjustUsched = 1;

static int AdjustCpuFreqOverride;

static volatile int stopped;

/* Battery life monitoring */
static int BatLifeMin = 2;	/* shutdown the box, if low on battery life */
static struct timespec BatLifePrevT;
static int BatLifePollIntvl = 5; /* unit: sec */
static struct timespec BatShutdownStartT;
static int BatShutdownLinger = -1;
static int BatShutdownLingerSet = 60; /* unit: sec */
static int BatShutdownLingerCnt;
static int BatShutdownAudioAlert = 1;
static int MinTemp = 75;
static int MaxTemp = 85;
static int BackLightPct = 100;
static int OldBackLightLevel;
static int BackLightDown;

static void sigintr(int signo);

int
main(int ac, char **av)
{
	double srt;
	double pollrate;
	int ch;
	int lowest;
	int highest;
	char buf[64];
	int monbat;
	char *p2;

	srt = 8.0;	/* time for samples - 8 seconds */
	pollrate = 1.0;	/* polling rate in seconds */

	while ((ch = getopt(ac, av, "b:cdefh:l:p:r:tu:B:H:L:P:QT:U")) != -1) {
		switch(ch) {
		case 'b':
			BackLightPct = strtol(optarg, NULL, 10);
			break;
		case 'c':
			AdjustCstate = 1;
			break;
		case 'd':
			DebugOpt = 1;
			break;
		case 'e':
			HasPerfbias = 1;
			break;
		case 'f':
			AdjustCpuFreq = 0;
			break;
		case 'h':
			HighestCpuFreq = strtol(optarg, NULL, 10);
			break;
		case 'l':
			LowestCpuFreq = strtol(optarg, NULL, 10);
			break;
		case 'p':
			Hysteresis = (int)strtol(optarg, NULL, 10);
			break;
		case 'r':
			pollrate = strtod(optarg, NULL);
			break;
		case 't':
			TurboOpt = 0;
			break;
		case 'u':
			TriggerUp = (double)strtol(optarg, NULL, 10) / 100;
			break;
		case 'B':
			BatLifeMin = strtol(optarg, NULL, 10);
			break;
		case 'H':
			MaxTemp = strtol(optarg, &p2, 0);
			if (*p2 == ':') {
				MinTemp = MaxTemp;
				MaxTemp = strtol(p2 + 1, NULL, 0);
			} else {
				MinTemp = MaxTemp * 9 / 10;
			}
			break;
		case 'L':
			BatShutdownLingerSet = strtol(optarg, NULL, 10);
			if (BatShutdownLingerSet < 0)
				BatShutdownLingerSet = 0;
			break;
		case 'P':
			BatLifePollIntvl = strtol(optarg, NULL, 10);
			break;
		case 'Q':
			BatShutdownAudioAlert = 0;
			break;
		case 'T':
			srt = strtod(optarg, NULL);
			break;
		case 'U':
			AdjustUsched = 0;
			break;
		default:
			usage();
			/* NOT REACHED */
		}
	}
	ac -= optind;
	av += optind;

	setlinebuf(stdout);

	/* Get number of cpus */
	get_ncpus();

	/* Seed FreqAry[] */
	acpi_get_cpufreq(0, &lowest, &highest);

	if (Hysteresis < 0 || Hysteresis > 99) {
		fprintf(stderr, "Invalid hysteresis value\n");
		exit(1);
	}

	if (TriggerUp < 0 || TriggerUp > 1) {
		fprintf(stderr, "Invalid load limit value\n");
		exit(1);
	}

	if (BackLightPct > 100 || BackLightPct <= 0) {
		fprintf(stderr, "Invalid backlight setting, ignore\n");
		BackLightPct = 100;
	}

	TriggerDown = TriggerUp - (TriggerUp * (double) Hysteresis / 100);

	/*
	 * Make sure powerd is not already running.
	 */
	PowerFd = open("/var/run/powerd.pid", O_CREAT|O_RDWR, 0644);
	if (PowerFd < 0) {
		fprintf(stderr,
			"Cannot create /var/run/powerd.pid, "
			"continuing anyway\n");
	} else {
		ssize_t r;
		pid_t pid = -1;

		r = read(PowerFd, buf, sizeof(buf) - 1);
		if (r > 0) {
			buf[r] = 0;
			pid = strtol(buf, NULL, 0);
		}
		if (flock(PowerFd, LOCK_EX|LOCK_NB) < 0) {
			if (pid > 0) {
				kill(pid, SIGTERM);
				flock(PowerFd, LOCK_EX);
				fprintf(stderr, "restarting powerd\n");
			} else {
				fprintf(stderr,
					"powerd is already running, "
					"unable to kill pid for restart\n");
				exit(1);
			}
		}
		lseek(PowerFd, 0L, 0);
	}

	/*
	 * Demonize and set pid
	 */
	if (DebugOpt == 0) {
		daemon(0, 0);
		openlog("powerd", LOG_CONS | LOG_PID, LOG_DAEMON);
	}

	if (PowerFd >= 0) {
		ftruncate(PowerFd, 0);
		snprintf(buf, sizeof(buf), "%d\n", (int)getpid());
		write(PowerFd, buf, strlen(buf));
	}

	/* Do we need to monitor battery life? */
	if (BatLifePollIntvl <= 0)
		monbat = 0;
	else
		monbat = has_battery();

	/* Do we have perfbias(4)? */
	if (HasPerfbias)
		HasPerfbias = has_perfbias();

	/* Could we adjust C-state? */
	if (AdjustCstate)
		AdjustCstate = probe_cstate();

	/*
	 * Wait hw.acpi.cpu.px_dom* sysctl to be created by kernel.
	 *
	 * Since hw.acpi.cpu.px_dom* creation is queued into ACPI
	 * taskqueue and ACPI taskqueue is shared across various
	 * ACPI modules, any delay in other modules may cause
	 * hw.acpi.cpu.px_dom* to be created at quite a later time
	 * (e.g. cmbat module's task could take quite a lot of time).
	 */
	for (;;) {
		/* Prime delta cputime calculation. */
		get_cputime(pollrate);

		/* Wait for all cpus to appear */
		if (acpi_get_cpupwrdom())
			break;
		usleep((int)(pollrate * 1000000.0));
	}

	/*
	 * Catch some signals so that max performance could be restored.
	 */
	signal(SIGINT, sigintr);
	signal(SIGTERM, sigintr);

	/* Initialize performance states */
	init_perf();

	srt = srt / pollrate;	/* convert to sample count */
	if (DebugOpt)
		printf("samples for downgrading: %5.2f\n", srt);

	/*
	 * Monitoring loop
	 */
	while (!stopped) {
		/*
		 * Monitor performance
		 */
		get_cputime(pollrate);
		mon_cputemp();
		mon_perf(srt);

		/*
		 * Monitor battery
		 */
		if (monbat)
			monbat = mon_battery();

		usleep((int)(pollrate * 1000000.0));
	}

	/*
	 * Set to maximum performance if killed.
	 */
	syslog(LOG_INFO, "killed, setting max and exiting");
	if (SavedPXGlobal)
		set_global_freq(SavedPXGlobal);
	restore_perf();
	restore_backlight();

	exit(0);
}

static void
sigintr(int signo __unused)
{
	stopped = 1;
}

/*
 * Figure out the cpu power domains.
 */
static int
acpi_get_cpupwrdom(void)
{
	struct cpu_pwrdom *dom;
	cpumask_t pwrdom_mask;
	char buf[64];
	char members[1024];
	char *str;
	size_t msize;
	int n, i, ncpu = 0, dom_id;

	memset(cpu2pwrdom, 0, sizeof(cpu2pwrdom));
	memset(cpu_pwrdomain, 0, sizeof(cpu_pwrdomain));
	CPUMASK_ASSZERO(cpu_pwrdom_mask);

	for (i = 0; i < MAXDOM; ++i) {
		snprintf(buf, sizeof(buf),
			 "hw.acpi.cpu.px_dom%d.available", i);
		if (sysctlbyname(buf, NULL, NULL, NULL, 0) < 0)
			continue;

		dom = calloc(1, sizeof(*dom));
		dom->dom_id = i;

		if (cpu_pwrdomain[i] != NULL) {
			fprintf(stderr, "cpu power domain %d exists\n", i);
			exit(1);
		}
		cpu_pwrdomain[i] = dom;
		CPUMASK_ORBIT(cpu_pwrdom_mask, i);
	}
	pwrdom_mask = cpu_pwrdom_mask;

	while (CPUMASK_TESTNZERO(pwrdom_mask)) {
		dom_id = BSFCPUMASK(pwrdom_mask);
		CPUMASK_NANDBIT(pwrdom_mask, dom_id);
		dom = cpu_pwrdomain[dom_id];

		CPUMASK_ASSZERO(dom->dom_cpumask);

		snprintf(buf, sizeof(buf),
			 "hw.acpi.cpu.px_dom%d.members", dom->dom_id);
		msize = sizeof(members);
		if (sysctlbyname(buf, members, &msize, NULL, 0) < 0) {
			cpu_pwrdomain[dom_id] = NULL;
			free(dom);
			continue;
		}

		members[msize] = 0;
		for (str = strtok(members, " "); str; str = strtok(NULL, " ")) {
			n = -1;
			sscanf(str, "cpu%d", &n);
			if (n >= 0) {
				++ncpu;
				++dom->dom_ncpus;
				CPUMASK_ORBIT(dom->dom_cpumask, n);
				cpu2pwrdom[n] = dom->dom_id;
			}
		}
		if (dom->dom_ncpus == 0) {
			cpu_pwrdomain[dom_id] = NULL;
			free(dom);
			continue;
		}
		if (DebugOpt) {
			printf("dom%d cpumask: ", dom->dom_id);
			for (i = 0; i < (int)NELEM(dom->dom_cpumask.ary); ++i) {
				printf("%jx ",
				    (uintmax_t)dom->dom_cpumask.ary[i]);
			}
			printf("\n");
		}
	}

	if (ncpu != NCpus) {
		if (DebugOpt)
			printf("Found %d cpus, expecting %d\n", ncpu, NCpus);

		pwrdom_mask = cpu_pwrdom_mask;
		while (CPUMASK_TESTNZERO(pwrdom_mask)) {
			dom_id = BSFCPUMASK(pwrdom_mask);
			CPUMASK_NANDBIT(pwrdom_mask, dom_id);
			dom = cpu_pwrdomain[dom_id];
			if (dom != NULL)
				free(dom);
		}
		return 0;
	}
	return 1;
}

/*
 * Save per-cpu load and sum of per-cpu load.
 */
static void
get_cputime(double pollrate)
{
	static struct kinfo_cputime ocpu_time[MAXCPU];
	static struct kinfo_cputime ncpu_time[MAXCPU];
	size_t slen;
	int ncpu;
	int cpu;
	uint64_t delta;

	bcopy(ncpu_time, ocpu_time, sizeof(struct kinfo_cputime) * NCpus);

	slen = sizeof(ncpu_time);
	if (sysctlbyname("kern.cputime", &ncpu_time, &slen, NULL, 0) < 0) {
		fprintf(stderr, "kern.cputime sysctl not available\n");
		exit(1);
	}
	ncpu = slen / sizeof(ncpu_time[0]);

	delta = 0;
	for (cpu = 0; cpu < ncpu; ++cpu) {
		uint64_t d;

		d = (ncpu_time[cpu].cp_user + ncpu_time[cpu].cp_sys +
		     ncpu_time[cpu].cp_nice + ncpu_time[cpu].cp_intr) -
		    (ocpu_time[cpu].cp_user + ocpu_time[cpu].cp_sys +
		     ocpu_time[cpu].cp_nice + ocpu_time[cpu].cp_intr);
		pcpu_state[cpu].cpu_qavg = (double)d / (pollrate * 1000000.0);

		delta += d;
	}
	global_cpu_state.cpu_qavg = (double)delta / (pollrate * 1000000.0);
}

static void
acpi_getcpufreq_str(int dom_id, int *highest0, int *lowest0)
{
	char buf[256], sysid[64];
	size_t buflen;
	char *ptr;
	int v, highest, lowest;
	int freqidx;

	/*
	 * Retrieve availability list
	 */
	snprintf(sysid, sizeof(sysid),
		 "hw.acpi.cpu.px_dom%d.available", dom_id);
	buflen = sizeof(buf) - 1;
	if (sysctlbyname(sysid, buf, &buflen, NULL, 0) < 0)
		return;
	buf[buflen] = 0;

	/*
	 * Parse out the highest and lowest cpu frequencies
	 */
	ptr = buf;
	highest = lowest = 0;
	freqidx = 0;
	while (ptr && (v = strtol(ptr, &ptr, 10)) > 0) {
		if ((lowest == 0 || lowest > v) &&
		    (LowestCpuFreq <= 0 || v >= LowestCpuFreq))
			lowest = v;
		if ((highest == 0 || highest < v) &&
		    (HighestCpuFreq <= 0 || v <= HighestCpuFreq))
			highest = v;
		/*
		 * Detect turbo mode
		 */
		if (!TurboOpt && highest - v == 1)
			highest = v;
		++freqidx;
	}

	/*
	 * Frequency array
	 */
	if (freqidx > MAXFREQ)
		freqidx = MAXFREQ;
	if (NFreq != freqidx) {
		NFreq = freqidx;
		NFreqChanged = NFREQ_ALL;
	}
	ptr = buf;
	while (ptr && (v = strtol(ptr, &ptr, 10)) > 0) {
		if (freqidx == 0)
			break;
		if (FreqAry[freqidx - 1] != v)
			NFreqChanged = NFREQ_ALL;
		FreqAry[--freqidx] = v;
	}

	*highest0 = highest;
	*lowest0 = lowest;
}

static int
acpi_getcpufreq_bin(int dom_id, int *highest0, int *lowest0)
{
	char sysid[64];
	size_t freqlen;
	int freqcnt, i;
	int freqary[MAXFREQ];

	/*
	 * Retrieve availability list
	 */
	snprintf(sysid, sizeof(sysid), "hw.acpi.cpu.px_dom%d.avail", dom_id);
	freqlen = sizeof(FreqAry);
	bzero(freqary, sizeof(freqary));
	if (sysctlbyname(sysid, freqary, &freqlen, NULL, 0) < 0)
		return 0;

	freqcnt = freqlen / sizeof(freqary[0]);
	if (NFreq != freqcnt) {
		NFreq = freqcnt;
		NFreqChanged = NFREQ_ALL;
	}
	if (bcmp(freqary, FreqAry, sizeof(FreqAry)) != 0)
		NFreqChanged = NFREQ_ALL;
	bcopy(freqary, FreqAry, sizeof(FreqAry));
	if (freqcnt == 0)
		return 0;

	for (i = freqcnt - 1; i >= 0; --i) {
		*lowest0 = FreqAry[i];
		if (LowestCpuFreq <= 0 || *lowest0 >= LowestCpuFreq)
			break;
	}

	i = 0;
	*highest0 = FreqAry[0];
	if (!TurboOpt && freqcnt > 1 && FreqAry[0] - FreqAry[1] == 1) {
		i = 1;
		*highest0 = FreqAry[1];
	}
	for (; i < freqcnt; ++i) {
		if (HighestCpuFreq <= 0 || *highest0 <= HighestCpuFreq)
			break;
		*highest0 = FreqAry[i];
	}
	return 1;
}

static void
acpi_get_cpufreq(int dom_id, int *highest, int *lowest)
{
	*highest = 0;
	*lowest = 0;

	if (acpi_getcpufreq_bin(dom_id, highest, lowest))
		return;
	acpi_getcpufreq_str(dom_id, highest, lowest);
}

static
void
usage(void)
{
	fprintf(stderr, "usage: powerd [-cdeftQU] [-p hysteresis] "
	    "[-h highest_freq] [-l lowest_freq] "
	    "[-r poll_interval] [-u trigger_up] "
	    "[-B min_battery_life] [-L low_battery_linger] "
	    "[-P battery_poll_interval] [-T sample_interval] "
	    "[-b backlight]\n");
	exit(1);
}

#define BAT_SYSCTL_TIME_MAX	50000000 /* unit: nanosecond */

static int
has_battery(void)
{
	struct timespec s, e;
	size_t len;
	int val;

	clock_gettime(CLOCK_MONOTONIC_FAST, &s);
	BatLifePrevT = s;

	len = sizeof(val);
	if (sysctlbyname("hw.acpi.acline", &val, &len, NULL, 0) < 0) {
		/* No AC line information */
		return 0;
	}
	clock_gettime(CLOCK_MONOTONIC_FAST, &e);

	timespecsub(&e, &s, &e);
	if (e.tv_sec > 0 || e.tv_nsec > BAT_SYSCTL_TIME_MAX) {
		/* hw.acpi.acline takes to long to be useful */
		syslog(LOG_NOTICE, "hw.acpi.acline takes too long");
		return 0;
	}

	clock_gettime(CLOCK_MONOTONIC_FAST, &s);
	len = sizeof(val);
	if (sysctlbyname("hw.acpi.battery.life", &val, &len, NULL, 0) < 0) {
		/* No battery life */
		return 0;
	}
	clock_gettime(CLOCK_MONOTONIC_FAST, &e);

	timespecsub(&e, &s, &e);
	if (e.tv_sec > 0 || e.tv_nsec > BAT_SYSCTL_TIME_MAX) {
		/* hw.acpi.battery.life takes to long to be useful */
		syslog(LOG_NOTICE, "hw.acpi.battery.life takes too long");
		return 0;
	}
	return 1;
}

static void
low_battery_alert(int life)
{
	int fmt, stereo, freq;
	int fd;

	syslog(LOG_ALERT, "low battery life %d%%, please plugin AC line, #%d",
	    life, BatShutdownLingerCnt);
	++BatShutdownLingerCnt;

	if (!BatShutdownAudioAlert)
		return;

	fd = open("/dev/dsp", O_WRONLY);
	if (fd < 0)
		return;

	fmt = AFMT_S16_LE;
	if (ioctl(fd, SNDCTL_DSP_SETFMT, &fmt, sizeof(fmt)) < 0)
		goto done;

	stereo = 0;
	if (ioctl(fd, SNDCTL_DSP_STEREO, &stereo, sizeof(stereo)) < 0)
		goto done;

	freq = 44100;
	if (ioctl(fd, SNDCTL_DSP_SPEED, &freq, sizeof(freq)) < 0)
		goto done;

	write(fd, alert1, sizeof(alert1));
	write(fd, alert1, sizeof(alert1));

done:
	close(fd);
}

static int
mon_battery(void)
{
	struct timespec cur, ts;
	int acline, life;
	size_t len;

	clock_gettime(CLOCK_MONOTONIC_FAST, &cur);
	timespecsub(&cur, &BatLifePrevT, &ts);
	if (ts.tv_sec < BatLifePollIntvl)
		return 1;
	BatLifePrevT = cur;

	len = sizeof(acline);
	if (sysctlbyname("hw.acpi.acline", &acline, &len, NULL, 0) < 0)
		return 1;
	if (acline) {
		BatShutdownLinger = -1;
		BatShutdownLingerCnt = 0;
		restore_backlight();
		return 1;
	}

	if (!BackLightDown && BackLightPct != 100) {
		int backlight_max, backlight;

		len = sizeof(backlight_max);
		if (sysctlbyname("hw.backlight_max", &backlight_max, &len,
		    NULL, 0) < 0) {
			/* No more backlight adjustment */
			BackLightPct = 100;
			goto after_backlight;
		}

		len = sizeof(OldBackLightLevel);
		if (sysctlbyname("hw.backlight_level", &OldBackLightLevel, &len,
		    NULL, 0) < 0) {
			/* No more backlight adjustment */
			BackLightPct = 100;
			goto after_backlight;
		}

		backlight = (backlight_max * BackLightPct) / 100;
		if (backlight >= OldBackLightLevel) {
			/* No more backlight adjustment */
			BackLightPct = 100;
			goto after_backlight;
		}

		if (sysctlbyname("hw.backlight_level", NULL, NULL,
		    &backlight, sizeof(backlight)) < 0) {
			/* No more backlight adjustment */
			BackLightPct = 100;
			goto after_backlight;
		}
		BackLightDown = 1;
	}
after_backlight:

	len = sizeof(life);
	if (sysctlbyname("hw.acpi.battery.life", &life, &len, NULL, 0) < 0)
		return 1;

	if (BatShutdownLinger > 0) {
		timespecsub(&cur, &BatShutdownStartT, &ts);
		if (ts.tv_sec > BatShutdownLinger)
			BatShutdownLinger = 0;
	}

	if (life <= BatLifeMin) {
		if (BatShutdownLinger == 0 || BatShutdownLingerSet == 0) {
			syslog(LOG_ALERT, "low battery life %d%%, "
			    "shutting down", life);
			if (vfork() == 0)
				execlp("poweroff", "poweroff", NULL);
			return 0;
		} else if (BatShutdownLinger < 0) {
			BatShutdownLinger = BatShutdownLingerSet;
			BatShutdownStartT = cur;
		}
		low_battery_alert(life);
	}
	return 1;
}

static void
get_ncpus(void)
{
	size_t slen;

	slen = sizeof(NCpus);
	if (sysctlbyname("hw.ncpu", &NCpus, &slen, NULL, 0) < 0)
		err(1, "sysctlbyname hw.ncpu failed");
	if (DebugOpt)
		printf("hw.ncpu %d\n", NCpus);
}

static void
get_uschedcpus(void)
{
	size_t slen;

	slen = sizeof(usched_cpu_used);
	if (sysctlbyname("kern.usched_global_cpumask", &usched_cpu_used, &slen,
	    NULL, 0) < 0)
		err(1, "sysctlbyname kern.usched_global_cpumask failed");
	if (DebugOpt) {
		int i;

		printf("usched cpumask was: ");
		for (i = 0; i < (int)NELEM(usched_cpu_used.ary); ++i)
			printf("%jx ", (uintmax_t)usched_cpu_used.ary[i]);
		printf("\n");
	}
}

static void
set_uschedcpus(void)
{
	if (DebugOpt) {
		int i;

		printf("usched cpumask: ");
		for (i = 0; i < (int)NELEM(usched_cpu_used.ary); ++i) {
			printf("%jx ",
			    (uintmax_t)usched_cpu_used.ary[i]);
		}
		printf("\n");
	}
	sysctlbyname("kern.usched_global_cpumask", NULL, 0,
	    &usched_cpu_used, sizeof(usched_cpu_used));
}

static int
has_perfbias(void)
{
	size_t len;
	int hint;

	len = sizeof(hint);
	if (sysctlbyname("machdep.perfbias0.hint", &hint, &len, NULL, 0) < 0)
		return 0;
	return 1;
}

static void
set_perfbias(int cpu, int inc)
{
	int hint = inc ? 0 : 15;
	char sysid[64];

	if (DebugOpt)
		printf("cpu%d set perfbias hint %d\n", cpu, hint);
	snprintf(sysid, sizeof(sysid), "machdep.perfbias%d.hint", cpu);
	sysctlbyname(sysid, NULL, NULL, &hint, sizeof(hint));
}

static void
init_perf(void)
{
	struct cpu_state *state;
	int cpu;

	/* Get usched cpumask */
	get_uschedcpus();

	/*
	 * Assume everything are used and are maxed out, before we
	 * start.
	 */
	CPUMASK_ASSBMASK(cpu_used, NCpus);
	cpu_pwrdom_used = cpu_pwrdom_mask;
	global_pcpu_limit = NCpus;

	for (cpu = 0; cpu < NCpus; ++cpu) {
		state = &pcpu_state[cpu];

		state->cpu_uavg = 0.0;
		state->cpu_davg = 0.0;
		state->cpu_limit = 1;
		state->cpu_count = 1;
		snprintf(state->cpu_name, sizeof(state->cpu_name), "cpu%d",
		    cpu);
	}

	state = &global_cpu_state;
	state->cpu_uavg = 0.0;
	state->cpu_davg = 0.0;
	state->cpu_limit = NCpus;
	state->cpu_count = NCpus;
	strlcpy(state->cpu_name, "global", sizeof(state->cpu_name));
}

static int
get_nstate(struct cpu_state *state, double srt)
{
	int ustate, dstate, nstate;

	/* speeding up */
	state->cpu_uavg = (state->cpu_uavg * 2.0 + state->cpu_qavg) / 3.0;
	/* slowing down */
	state->cpu_davg = (state->cpu_davg * srt + state->cpu_qavg) / (srt + 1);
	if (state->cpu_davg < state->cpu_uavg)
		state->cpu_davg = state->cpu_uavg;

	ustate = state->cpu_uavg / TriggerUp;
	if (ustate < state->cpu_limit)
		ustate = state->cpu_uavg / TriggerDown;
	dstate = state->cpu_davg / TriggerUp;
	if (dstate < state->cpu_limit)
		dstate = state->cpu_davg / TriggerDown;

	nstate = (ustate > dstate) ? ustate : dstate;
	if (nstate > state->cpu_count)
		nstate = state->cpu_count;

	if (DebugOpt) {
		printf("%s qavg=%5.2f uavg=%5.2f davg=%5.2f "
		    "%2d ncpus=%d\n", state->cpu_name,
		    state->cpu_qavg, state->cpu_uavg, state->cpu_davg,
		    state->cpu_limit, nstate);
	}
	return nstate;
}

static void
mon_perf(double srt)
{
	cpumask_t ocpu_used, ocpu_pwrdom_used;
	int pnstate = 0, nstate;
	int cpu;

	/*
	 * Find cpus requiring performance and their cooresponding power
	 * domains.  Save the number of cpus requiring performance in
	 * pnstate.
	 */
	ocpu_used = cpu_used;
	ocpu_pwrdom_used = cpu_pwrdom_used;

	CPUMASK_ASSZERO(cpu_used);
	CPUMASK_ASSZERO(cpu_pwrdom_used);

	for (cpu = 0; cpu < NCpus; ++cpu) {
		struct cpu_state *state = &pcpu_state[cpu];
		int s;

		s = get_nstate(state, srt);
		if (s) {
			CPUMASK_ORBIT(cpu_used, cpu);
			CPUMASK_ORBIT(cpu_pwrdom_used, cpu2pwrdom[cpu]);
		}
		pnstate += s;

		state->cpu_limit = s;
	}

	/*
	 * Calculate nstate, the number of cpus we wish to run at max
	 * performance.
	 */
	nstate = get_nstate(&global_cpu_state, srt);

	if (nstate == global_cpu_state.cpu_limit &&
	    (NFreqChanged & NFREQ_MONPERF) == 0 &&
	    (pnstate == global_pcpu_limit || nstate > pnstate)) {
		/* Nothing changed; keep the sets */
		cpu_used = ocpu_used;
		cpu_pwrdom_used = ocpu_pwrdom_used;

		global_pcpu_limit = pnstate;
		return;
	}
	NFreqChanged &= ~NFREQ_MONPERF;
	global_pcpu_limit = pnstate;

	if (nstate > pnstate) {
		/*
		 * Add spare cpus to meet global performance requirement.
		 */
		add_spare_cpus(ocpu_used, nstate - pnstate);
	}

	global_cpu_state.cpu_limit = nstate;

	/*
	 * Adjust cpu and cpu power domain performance
	 */
	adj_perf(ocpu_used, ocpu_pwrdom_used);
}

static void
add_spare_cpus(const cpumask_t ocpu_used, int ncpu)
{
	cpumask_t saved_pwrdom, xcpu_used;
	int done = 0, cpu;

	/*
	 * Find more cpus in the previous cpu set.
	 */
	xcpu_used = cpu_used;
	CPUMASK_XORMASK(xcpu_used, ocpu_used);
	while (CPUMASK_TESTNZERO(xcpu_used)) {
		cpu = BSFCPUMASK(xcpu_used);
		CPUMASK_NANDBIT(xcpu_used, cpu);

		if (CPUMASK_TESTBIT(ocpu_used, cpu)) {
			CPUMASK_ORBIT(cpu_pwrdom_used, cpu2pwrdom[cpu]);
			CPUMASK_ORBIT(cpu_used, cpu);
			--ncpu;
			if (ncpu == 0)
				return;
		}
	}

	/*
	 * Find more cpus in the used cpu power domains.
	 */
	saved_pwrdom = cpu_pwrdom_used;
again:
	while (CPUMASK_TESTNZERO(saved_pwrdom)) {
		cpumask_t unused_cpumask;
		int dom;

		dom = BSFCPUMASK(saved_pwrdom);
		CPUMASK_NANDBIT(saved_pwrdom, dom);

		unused_cpumask = cpu_pwrdomain[dom]->dom_cpumask;
		CPUMASK_NANDMASK(unused_cpumask, cpu_used);

		while (CPUMASK_TESTNZERO(unused_cpumask)) {
			cpu = BSFCPUMASK(unused_cpumask);
			CPUMASK_NANDBIT(unused_cpumask, cpu);

			CPUMASK_ORBIT(cpu_pwrdom_used, dom);
			CPUMASK_ORBIT(cpu_used, cpu);
			--ncpu;
			if (ncpu == 0)
				return;
		}
	}
	if (!done) {
		done = 1;
		/*
		 * Find more cpus in unused cpu power domains
		 */
		saved_pwrdom = cpu_pwrdom_mask;
		CPUMASK_NANDMASK(saved_pwrdom, cpu_pwrdom_used);
		goto again;
	}
	if (DebugOpt)
		printf("%d cpus not found\n", ncpu);
}

static void
acpi_set_cpufreq(int dom, int inc)
{
	int lowest, highest, desired;
	char sysid[64];

	acpi_get_cpufreq(dom, &highest, &lowest);
	if (highest == 0 || lowest == 0)
		return;
	desired = inc ? highest : lowest;

	if (DebugOpt)
		printf("dom%d set frequency %d\n", dom, desired);
	snprintf(sysid, sizeof(sysid), "hw.acpi.cpu.px_dom%d.select", dom);
	sysctlbyname(sysid, NULL, NULL, &desired, sizeof(desired));
}

static void
adj_cpu_pwrdom(int dom, int inc)
{
	if (AdjustCpuFreq && (inc == 0 || AdjustCpuFreqOverride == 0))
		acpi_set_cpufreq(dom, inc);
}

static void
adj_cpu_perf(int cpu, int inc)
{
	if (DebugOpt) {
		if (inc)
			printf("cpu%d increase perf\n", cpu);
		else
			printf("cpu%d decrease perf\n", cpu);
	}

	if (HasPerfbias)
		set_perfbias(cpu, inc);
	if (AdjustCstate)
		set_cstate(cpu, inc);
}

static void
adj_perf(cpumask_t xcpu_used, cpumask_t xcpu_pwrdom_used)
{
	int cpu, inc;

	if (AdjustUsched) {
		cpumask_t old_usched_used;

		/*
		 * Set cpus requiring performance to the userland process
		 * scheduler.  Leave the rest of cpus unmapped.
		 */
		old_usched_used = usched_cpu_used;
		usched_cpu_used = cpu_used;
		if (CPUMASK_TESTZERO(usched_cpu_used))
			CPUMASK_ORBIT(usched_cpu_used, 0);
		if (CPUMASK_CMPMASKNEQ(usched_cpu_used, old_usched_used))
			set_uschedcpus();
	}

	/*
	 * Adjust per-cpu performance for any cpus which changed.
	 */
	CPUMASK_XORMASK(xcpu_used, cpu_used);
	if (NFreqChanged & NFREQ_ADJPERF)
		CPUMASK_ASSBMASK(xcpu_used, NCpus);
	while (CPUMASK_TESTNZERO(xcpu_used)) {
		cpu = BSFCPUMASK(xcpu_used);
		CPUMASK_NANDBIT(xcpu_used, cpu);

		if (CPUMASK_TESTBIT(cpu_used, cpu)) {
			/* Increase cpu performance */
			inc = 1;
		} else {
			/* Decrease cpu performance */
			inc = 0;
		}
		adj_cpu_perf(cpu, inc);
	}

	/*
	 * Adjust cpu power domain performance.  This could affect
	 * a set of cpus.
	 */
	CPUMASK_XORMASK(xcpu_pwrdom_used, cpu_pwrdom_used);
	if (NFreqChanged & NFREQ_ADJPERF)
		CPUMASK_ASSBMASK(xcpu_pwrdom_used, NCpus);
	while (CPUMASK_TESTNZERO(xcpu_pwrdom_used)) {
		int dom;

		dom = BSFCPUMASK(xcpu_pwrdom_used);
		CPUMASK_NANDBIT(xcpu_pwrdom_used, dom);

		if (CPUMASK_TESTBIT(cpu_pwrdom_used, dom)) {
			/* Increase cpu power domain performance */
			inc = 1;
		} else {
			/* Decrease cpu power domain performance */
			inc = 0;
		}
		adj_cpu_pwrdom(dom, inc);
	}
	NFreqChanged &= ~NFREQ_ADJPERF;
}

static void
restore_perf(void)
{
	cpumask_t ocpu_used, ocpu_pwrdom_used;

	/* Remove highest cpu frequency limitation */
	HighestCpuFreq = 0;

	ocpu_used = cpu_used;
	ocpu_pwrdom_used = cpu_pwrdom_used;

	/* Max out all cpus and cpu power domains performance */
	CPUMASK_ASSBMASK(cpu_used, NCpus);
	cpu_pwrdom_used = cpu_pwrdom_mask;

	adj_perf(ocpu_used, ocpu_pwrdom_used);

	if (AdjustCstate) {
		/*
		 * Restore the original mwait C-state
		 */
		if (DebugOpt)
			printf("global set cstate %s\n", orig_global_cx);
		sysctlbyname("machdep.mwait.CX.idle", NULL, NULL,
		    orig_global_cx, strlen(orig_global_cx) + 1);
	}
}

static int
probe_cstate(void)
{
	char cx_supported[1024];
	const char *target;
	char *ptr;
	int idle_hlt, deep = 1;
	size_t len;

	len = sizeof(idle_hlt);
	if (sysctlbyname("machdep.cpu_idle_hlt", &idle_hlt, &len, NULL, 0) < 0)
		return 0;
	if (idle_hlt != 1)
		return 0;

	len = sizeof(cx_supported);
	if (sysctlbyname("machdep.mwait.CX.supported", cx_supported, &len,
	    NULL, 0) < 0)
		return 0;

	len = sizeof(orig_global_cx);
	if (sysctlbyname("machdep.mwait.CX.idle", orig_global_cx, &len,
	    NULL, 0) < 0)
		return 0;

	strlcpy(cpu_perf_cx, "AUTODEEP", sizeof(cpu_perf_cx));
	cpu_perf_cxlen = strlen(cpu_perf_cx) + 1;
	if (sysctlbyname("machdep.mwait.CX.idle", NULL, NULL,
	    cpu_perf_cx, cpu_perf_cxlen) < 0) {
		/* AUTODEEP is not supported; try AUTO */
		deep = 0;
		strlcpy(cpu_perf_cx, "AUTO", sizeof(cpu_perf_cx));
		cpu_perf_cxlen = strlen(cpu_perf_cx) + 1;
		if (sysctlbyname("machdep.mwait.CX.idle", NULL, NULL,
		    cpu_perf_cx, cpu_perf_cxlen) < 0)
			return 0;
	}

	if (!deep)
		target = "C2/0";
	else
		target = NULL;
	for (ptr = strtok(cx_supported, " "); ptr != NULL;
	     ptr = strtok(NULL, " ")) {
		if (target == NULL ||
		    (target != NULL && strcmp(ptr, target) == 0)) {
			strlcpy(cpu_idle_cx, ptr, sizeof(cpu_idle_cx));
			cpu_idle_cxlen = strlen(cpu_idle_cx) + 1;
			if (target != NULL)
				break;
		}
	}
	if (cpu_idle_cxlen == 0)
		return 0;

	if (DebugOpt) {
		printf("cstate orig %s, perf %s, idle %s\n",
		    orig_global_cx, cpu_perf_cx, cpu_idle_cx);
	}
	return 1;
}

static void
set_cstate(int cpu, int inc)
{
	const char *cst;
	char sysid[64];
	size_t len;

	if (inc) {
		cst = cpu_perf_cx;
		len = cpu_perf_cxlen;
	} else {
		cst = cpu_idle_cx;
		len = cpu_idle_cxlen;
	}

	if (DebugOpt)
		printf("cpu%d set cstate %s\n", cpu, cst);
	snprintf(sysid, sizeof(sysid), "machdep.mwait.CX.idle%d", cpu);
	sysctlbyname(sysid, NULL, NULL, cst, len);
}

static void
restore_backlight(void)
{
	if (BackLightDown) {
		BackLightDown = 0;
		sysctlbyname("hw.backlight_level", NULL, NULL,
		    &OldBackLightLevel, sizeof(OldBackLightLevel));
	}
}

/*
 * get_cputemp() / mon_cputemp()
 *
 * This enforces the maximum cpu frequency based on temperature
 * verses MinTemp and MaxTemp.
 */
static int
get_cputemp(void)
{
	char sysid[64];
	struct sensor sensor;
	size_t sensor_size;
	int t;
	int mt = -1;
	int n;

	for (n = 0; ; ++n) {
		t = 0;
		snprintf(sysid, sizeof(sysid),
			 "hw.sensors.cpu_node%d.temp0", n);
		sensor_size = sizeof(sensor);
		if (sysctlbyname(sysid, &sensor, &sensor_size, NULL, 0) < 0)
			break;
		t = -1;
		if ((sensor.flags & (SENSOR_FINVALID | SENSOR_FUNKNOWN)) == 0) {
			t = (int)((sensor.value - 273150000) / 1000000);
			if (mt < t)
				mt = t;
		}
	}
	if (n)
		return mt;

	/*
	 * Missing nodeN for some reason, try cpuN.
	 */
	for (n = 0; ; ++n) {
		t = 0;
		snprintf(sysid, sizeof(sysid),
			 "hw.sensors.cpu%d.temp0", n);
		sensor_size = sizeof(sensor);
		if (sysctlbyname(sysid, &sensor, &sensor_size, NULL, 0) < 0)
			break;
		t = -1;
		if ((sensor.flags & (SENSOR_FINVALID | SENSOR_FUNKNOWN)) == 0) {
			t = (int)((sensor.value - 273150000) / 1000000);
			if (mt < t)
				mt = t;
		}
	}
	return mt;
}

static void
set_global_freq(int freq)
{
	if (freq > 0)
		sysctlbyname("hw.acpi.cpu.px_global",
			     NULL, NULL, &freq, sizeof(freq));
}

static int
get_global_freq(void)
{
	int freq;
	size_t freq_size;

	freq = -1;
	freq_size = sizeof(freq);
	sysctlbyname("hw.acpi.cpu.px_global", &freq, &freq_size, NULL, 0);

	return freq;
}

static void
mon_cputemp(void)
{
	static int last_temp = -1;
	static int last_idx = -1;
	int temp = get_cputemp();
	int idx;
	int lowest;
	int highest;
	static int CurPXGlobal __unused;

	/*
	 * Reseed FreqAry, it can change w/AC power state
	 */
	acpi_get_cpufreq(0, &lowest, &highest);

	/*
	 * Some cpu frequency steps can cause large shifts in cpu temperature,
	 * creating an oscillation that min-maxes the temperature in a way
	 * that is not desireable.  To deal with this, we impose an exponential
	 * average for any temperature change.
	 *
	 * We have to do this in both directions, otherwise (in particular)
	 * laptop fan responsiveness and temperature sensor response times
	 * can create major frequency oscillations.
	 */
	if (last_temp < 0 || (NFreqChanged & NFREQ_CPUTEMP)) {
		NFreqChanged &= ~NFREQ_CPUTEMP;
		last_temp = temp << 8;
	} else if (temp < last_temp) {
		last_temp = (last_temp * 15 + (temp << 8)) / 16;
		if (DebugOpt) {
			printf("Falling temp %d (use %d)\n",
				temp, (last_temp >> 8));
		}
	} else {
		last_temp = (last_temp * 15 + (temp << 8)) / 16;
		if (DebugOpt) {
			printf("Rising temp %d (use %d)\n",
				temp, (last_temp >> 8));
		}
	}
	temp = last_temp >> 8;

	/*
	 * CPU Temp not available or available frequencies not yet
	 * probed.
	 */
	if (DebugOpt)
		printf("Temp %d {%d-%d} NFreq=%d)\n",
		       temp, MinTemp, MaxTemp, NFreq);
	if (temp <= 0)
		return;
	if (NFreq == 0)
		return;

	/*
	 * Return to normal operation if under the minimum
	 */
	if (temp <= MinTemp) {
		if (AdjustCpuFreqOverride) {
			AdjustCpuFreqOverride = 0;
			CurPXGlobal = 0;
			NFreqChanged = NFREQ_ALL;
			last_idx = -1;
			syslog(LOG_ALERT,
			       "Temp below %d, returning to normal operation",
			       MinTemp);
			if (SavedPXGlobal)
				set_global_freq(SavedPXGlobal);
		}
		return;
	}

	/*
	 * Hysteresis before entering temperature control mode
	 */
	if (AdjustCpuFreqOverride == 0 &&
	    temp <= MinTemp + (MaxTemp - MinTemp) / 10 + 1) {
		return;
	}

	/*
	 * Override frequency controls (except for idle -> lowest)
	 */
	if (AdjustCpuFreqOverride == 0) {
		AdjustCpuFreqOverride = 1;
		SavedPXGlobal = get_global_freq();
		CurPXGlobal = 0;
		NFreqChanged = NFREQ_ALL;
		last_idx = -1;
		syslog(LOG_ALERT,
		       "Temp %d {%d-%d}, entering temperature control mode",
		       temp, MinTemp, MaxTemp);
	}
	if (temp > MaxTemp + (MaxTemp - MinTemp) / 10 + 1) {
		syslog(LOG_ALERT,
		       "Temp %d {%d-%d}, TOO HOT!!!",
		       temp, MinTemp, MaxTemp);
	}
	idx = (temp - MinTemp) * NFreq / (MaxTemp - MinTemp);
	if (idx < 0 || idx >= NFreq)	/* overtemp */
		idx = NFreq - 1;

	/*
	 * Limit frequency shifts to single steps in both directions.
	 * Some fans react very quickly, this will reduce oscillations.
	 */
	if (DebugOpt)
		printf("Temp index %d (use %d)\n", idx, last_idx);
	if (last_idx >= 0 && idx < last_idx)
		idx = last_idx - 1;
	else if (last_idx >= 0 && idx > last_idx)
		idx = last_idx + 1;
	last_idx = idx;

	/*
	 * One last thing, make sure our frequency adheres to
	 * HighestCpuFreq.  However, override LowestCpuFreq for
	 * temperature control purposes.
	 */
	while (HighestCpuFreq > 0 && idx < NFreq &&
	       FreqAry[idx] > HighestCpuFreq) {
		++idx;
	}
#if 0
	/*
	 * Currently ignore LowestCpuFreq if temp control thinks it
	 * needs to go lower
	 */
	while (LowestCpuFreq > 0 && idx > 0 &&
	       FreqAry[idx] < LowestCpuFreq) {
		--idx;
	}
#endif

	if (FreqAry[idx] != CurPXGlobal) {
		CurPXGlobal = FreqAry[idx];

#if 0
		/* this can get noisy so don't log for now */
		syslog(LOG_ALERT,
		       "Temp %d {%d-%d}, set frequency %d",
		       temp, MinTemp, MaxTemp, CurPXGlobal);
#endif
	}
	set_global_freq(CurPXGlobal);
}