path: root/usr/src/cmd/picl/plugins/sun4u/psvc/psvcpolicy/psvcpolicy.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * This file contains routines to support the Platform Services Plugin
 * These routines implement the platform independent environment monitoring
 * and control policies that may be invoked by a daemon thread within
 * the plugin
 */

#include <syslog.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <libintl.h>
#include <errno.h>
#include <fcntl.h>
#include <strings.h>
#include <libintl.h>
#include <sys/types.h>
#include <string.h>
#include <limits.h>
#include <picl.h>
#include <picltree.h>
#include <sys/types.h>
#include <string.h>
#include <psvc_objects.h>

#define	LOWTEMP_CRITICAL_MSG		\
	gettext("CRITICAL : LOW TEMPERATURE DETECTED %d, %s")
#define	LOWTEMP_WARNING_MSG		\
	gettext("WARNING : LOW TEMPERATURE DETECTED %d, %s")
#define	HIGHTEMP_CRITICAL_MSG		\
	gettext("CRITICAL : HIGH TEMPERATURE DETECTED %d, %s")
#define	HIGHTEMP_WARNING_MSG		\
	gettext("WARNING : HIGH TEMPERATURE DETECTED %d, %s")
#define	DEVICE_INSERTED_MSG	gettext("Device %s inserted")
#define	DEVICE_REMOVED_MSG	gettext("Device %s removed")
#define	DEVICE_FAILURE_MSG		\
	gettext("CRITICAL: Device %s failure detected by sensor %s\n")
#define	DEVICE_OK_MSG	gettext("Device %s OK")
#define	SECONDARY_FAN_FAIL_MSG	gettext("Secondary fan failure, device %s")
#define	KEYSWITCH_POS_READ_FAILED_MSG	\
	gettext("Keyswitch position could not be determined")
#define	KEYSWITCH_POS_CHANGED_MSG gettext("Keyswitch position changed to %s")
#define	GET_PRESENCE_FAILED_MSG		\
	gettext("Failed to get presence attribute, id = %s, errno = %d\n")
#define	GET_SENSOR_FAILED_MSG		\
	gettext("Failed to get sensor value, id = %s, errno = %d\n")
#define	PS_OVER_CURRENT_MSG		\
	gettext("WARNING: Power Supply overcurrent detected for %s\n")
#define	SET_LED_FAILED_MSG		\
	gettext("Failed to set LED state, id = %s, errno = %d\n")
#define	SET_FANSPEED_FAILED_MSG		\
	gettext("Failed to set fan speed, id = %s, errno = %d\n")
#define	FAN_MISSING_MSG			\
	gettext("WARNING: Fan missing, id = %s\n")
#define	TEMP_SENSOR_FAULT		\
	gettext("WARNING: Temperature Sensor %s returning faulty temp\n")
#define	TEMP_OFFSET	17

static char *shutdown_string = "shutdown -y -g 60 -i 5 \"OVERTEMP condition\"";

static int cpus_online = 0;

typedef struct seg_desc {
	int32_t segdesc;
	int16_t segoffset;
	int16_t seglength;
} seg_desc_t;

static int32_t threshold_names[] = {
	PSVC_HW_LO_SHUT_ATTR,
	PSVC_LO_SHUT_ATTR,
	PSVC_LO_WARN_ATTR,
	PSVC_NOT_USED,			/* LOW MODE which is not used */
	PSVC_OPTIMAL_TEMP_ATTR,
	PSVC_HI_WARN_ATTR,
	PSVC_HI_SHUT_ATTR,
	PSVC_HW_HI_SHUT_ATTR
};

/*
 * The I2C bus is noisy, and the state may be incorrectly reported as
 * having changed.  When the state changes, we attempt to confirm by
 * retrying.  If any retries indicate that the state has not changed, we
 * assume the state change(s) were incorrect and the state has not changed.
 * The following variables are used to store the tuneable values read in
 * from the optional i2cparam.conf file for this shared object library.
 */
static int n_read_temp = PSVC_THRESHOLD_COUNTER;
static int n_retry_keyswitch = PSVC_NUM_OF_RETRIES;
static int retry_sleep_keyswitch = 1;
static int n_retry_hotplug = PSVC_NUM_OF_RETRIES;
static int retry_sleep_hotplug = 1;
static int n_retry_fan_hotplug = PSVC_NUM_OF_RETRIES;
static int retry_sleep_fan_hotplug = 1;
static int n_retry_fan_present = PSVC_NUM_OF_RETRIES;
static int retry_sleep_fan_present = 1;

typedef struct {
	int *pvar;
	char *texttag;
} i2c_noise_param_t;

static i2c_noise_param_t i2cparams_sun4u[] = {
	&n_read_temp, "n_read_temp",
	&n_retry_keyswitch, "n_retry_keyswitch",
	&retry_sleep_keyswitch, "retry_sleep_keyswitch",
	&n_retry_hotplug, "n_retry_hotplug",
	&retry_sleep_hotplug, "retry_sleep_hotplug",
	&n_retry_fan_hotplug, "n_retry_fan_hotplug",
	&retry_sleep_fan_hotplug, "retry_sleep_fan_hotplug",
	&n_retry_fan_present, "n_retry_fan_present",
	&retry_sleep_fan_present, "retry_sleep_fan_present",
	NULL, NULL
};

#pragma init(i2cparams_sun4u_load)

static void
i2cparams_sun4u_debug(i2c_noise_param_t *pi2cparams, int usingDefaults)
{
	char s[128];
	i2c_noise_param_t *p;

	if (!usingDefaults) {
		(void) strncpy(s,
		    "# Values from /usr/platform/sun4u/lib/i2cparam.conf\n",
			sizeof (s) - 1);
		syslog(LOG_WARNING, "%s", s);
	} else {
		/* no file - we're using the defaults */
		(void) strncpy(s,
"# No /usr/platform/sun4u/lib/i2cparam.conf file, using defaults\n",
			sizeof (s) - 1);
	}
	(void) fputs(s, stdout);
	p = pi2cparams;
	while (p->pvar != NULL) {
		(void) snprintf(s, sizeof (s), "%s %d\n", p->texttag,
		    *(p->pvar));
		if (!usingDefaults)
			syslog(LOG_WARNING, "%s", s);
		(void) fputs(s, stdout);
		p++;
	}
}

static void
i2cparams_sun4u_load(void)
{
	FILE *fp;
	char *filename = "/usr/platform/sun4u/lib/i2cparam.conf";
	char s[128];
	char var[128];
	int val;
	i2c_noise_param_t *p;

	/* read thru the i2cparam.conf file and set variables */
	if ((fp = fopen(filename, "r")) != NULL) {
		while (fgets(s, sizeof (s), fp) != NULL) {
			if (s[0] == '#') /* skip comment lines */
				continue;
			/* try to find a string match and get the value */
			if (sscanf(s, "%127s %d", var, &val) != 2)
				continue;
			if (val < 1)
				val = 1;  /* clamp min value */
			p = &(i2cparams_sun4u[0]);
			while (p->pvar != NULL) {
				if (strncmp(p->texttag, var, sizeof (var)) ==
				    0) {
					*(p->pvar) = val;
					break;
				}
				p++;
			}
		}
		(void) fclose(fp);
	}
	/* output the values of the parameters */
	i2cparams_sun4u_debug(&(i2cparams_sun4u[0]), ((fp == NULL)? 1 : 0));
}


int32_t
psvc_update_thresholds_0(psvc_opaque_t hdlp, char *id)
{
	int32_t status = PSVC_SUCCESS;
	fru_info_t fru_data;
	char *fru, seg_name[2];
	int8_t seg_count, temp_array[8];
	int32_t match_count, i, j, seg_desc_start = 0x1806, temp_address;
	int32_t seg_found, temp;
	boolean_t present;
	seg_desc_t segment;

	status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
	if ((status != PSVC_SUCCESS) || (present != PSVC_PRESENT))
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &match_count,
	    PSVC_FRU);
	if (status == PSVC_FAILURE)
		return (status);

	for (i = 0; i < match_count; i++) {
		seg_found = 0;
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
		    &fru, PSVC_FRU, i);
		if (status != PSVC_SUCCESS)
			return (status);

		fru_data.buf_start = 0x1805;
		fru_data.buf = (char *)&seg_count;
		fru_data.read_size = 1;

		status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
		    &fru_data);
		if (status != PSVC_SUCCESS) {
			return (status);
		}
		for (j = 0; (j < seg_count) && (!seg_found); j++) {
			fru_data.buf_start = seg_desc_start;
			fru_data.buf = seg_name;
			fru_data.read_size = 2;

			status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
			    &fru_data);

			seg_desc_start = seg_desc_start + 2;
			fru_data.buf_start = seg_desc_start;
			fru_data.buf = (char *)&segment;
			fru_data.read_size = sizeof (seg_desc_t);

			status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
			    &fru_data);
			if (status != PSVC_SUCCESS) {
				syslog(LOG_ERR,
				    "Failed psvc_get_attr for FRU info\n");
				return (status);
			}
			seg_desc_start = seg_desc_start + sizeof (seg_desc_t);
			if (memcmp(seg_name, "SC", 2) == 0)
				seg_found = 1;
		}
		if (seg_found) {
			temp_address = segment.segoffset + TEMP_OFFSET;
			fru_data.buf_start = temp_address;
			fru_data.buf = (char *)&temp_array;
			fru_data.read_size = sizeof (temp_array);
			status = psvc_get_attr(hdlp, fru, PSVC_FRU_INFO_ATTR,
			    &fru_data);
			if (status != PSVC_SUCCESS) {
				syslog(LOG_ERR,
				    "Failed psvc_get_attr for FRU info\n");
				return (status);
			} else {
				for (j = 0; j < sizeof (temp_array); j++) {
					if (threshold_names[j] == PSVC_NOT_USED)
						continue;
					temp = temp_array[j];
					status = psvc_set_attr(hdlp, id,
					    threshold_names[j], &temp);
					if (status != PSVC_SUCCESS) {
						return (status);
					}
				}
			}
		} else {
			syslog(LOG_ERR, "No FRU Information for %s"
			    " using default temperatures\n", id);
		}
	}
	return (status);
}

#define	MAX_TEMP_SENSORS	256

static int32_t
check_temp(psvc_opaque_t hdlp, char *id, int32_t silent)
{
	int32_t		lo_warn, hi_warn, lo_shut, hi_shut;
	uint64_t	features;
	int32_t		temp;
	char		previous_state[32];
	char		led_state[32];
	char		state[32];
	char		fault[32];
	char		label[32];
	boolean_t	pr;
	int32_t		status = PSVC_SUCCESS;
	int8_t		fail = 0;
	static int	threshold_low_shut[MAX_TEMP_SENSORS] = {0};
	static int	threshold_high_shut[MAX_TEMP_SENSORS] = {0};
	static int	threshold_low_warn[MAX_TEMP_SENSORS] = {0};
	static int	threshold_high_warn[MAX_TEMP_SENSORS] = {0};
	int32_t		instance;

	status = psvc_get_attr(hdlp, id, PSVC_INSTANCE_ATTR, &instance);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &pr);
	if ((status != PSVC_SUCCESS) || (pr != PSVC_PRESENT)) {
		return (status);
	}

	status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status == PSVC_FAILURE)
		return (status);

	if ((strcmp(state, PSVC_HOTPLUGGED) == 0)) {
		return (PSVC_SUCCESS);
	}

	status = psvc_get_attr(hdlp, id, PSVC_FEATURES_ATTR, &features);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_LO_WARN_ATTR, &lo_warn);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_LO_SHUT_ATTR, &lo_shut);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_HI_WARN_ATTR, &hi_warn);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_HI_SHUT_ATTR, &hi_shut);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_SENSOR_VALUE_ATTR, &temp);
	if (status != PSVC_SUCCESS) {
		return (status);
	}

	/*
	 * The following code is to check to see if the temp sensor is
	 * returning a faulty reading due to it either being bad or the
	 * CPU being powered off for some reason. Is so we will alert the user
	 * and just label the sensor bad but not the WHOLE CPU module.
	 */
	if ((temp == 127) && (strcmp(state, PSVC_ERROR) != 0)) {
		status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_ERROR);
		if (status != PSVC_SUCCESS)
			return (status);
		status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
		    PSVC_GEN_FAULT);
		if (status != PSVC_SUCCESS)
			return (status);
		syslog(LOG_ERR, TEMP_SENSOR_FAULT, id);
		return (status);
	}

	status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
	if (status != PSVC_SUCCESS)
		return (status);

	/*
	 * if any of the four temperature states (lo_shut, lo_warn,
	 * hi_shut, hi_warn) is detected we will not take an action
	 * until the number of similar back-to-back readings equals
	 * 'n_read_temp' (default is PSVC_THRESHOLD_COUNTER).
	 */
	if ((features & PSVC_LOW_SHUT) && temp < lo_shut) {
		/*
		 * once we are in one state, clear all the
		 * counters for the other three states since
		 * back-to-back readings of these other three
		 * states could not happen anymore.
		 */
		threshold_low_warn[instance] = 0;
		threshold_high_shut[instance] = 0;
		threshold_high_warn[instance] = 0;
		threshold_low_shut[instance]++;
		if (threshold_low_shut[instance] == n_read_temp) {
			threshold_low_shut[instance] = 0;
			fail = 1;
			strcpy(state, PSVC_ERROR);
			strcpy(fault, PSVC_TEMP_LO_SHUT);
			strcpy(led_state, PSVC_LED_ON);
			if (silent == 0)
				syslog(LOG_ERR, LOWTEMP_CRITICAL_MSG,
				    temp, label);
		} else { /* Threshold for showing error not reached */
			return (PSVC_SUCCESS);
		}
	} else if ((features & PSVC_LOW_WARN) && temp < lo_warn) {
		threshold_low_shut[instance] = 0;
		threshold_high_shut[instance] = 0;
		threshold_high_warn[instance] = 0;
		threshold_low_warn[instance]++;
		if (threshold_low_warn[instance] == n_read_temp) {
			threshold_low_warn[instance] = 0;
			fail = 1;
			strcpy(state, PSVC_ERROR);
			strcpy(fault, PSVC_TEMP_LO_WARN);
			strcpy(led_state, PSVC_LED_ON);
			if (silent == 0)
				syslog(LOG_ERR, LOWTEMP_WARNING_MSG,
				    temp, label);
		} else { /* Threshold for showing error not reached */
			return (PSVC_SUCCESS);
		}
	} else if ((features & PSVC_HIGH_SHUT) && temp > hi_shut) {
		threshold_low_warn[instance] = 0;
		threshold_low_shut[instance] = 0;
		threshold_high_warn[instance] = 0;
		threshold_high_shut[instance]++;
		if (threshold_high_shut[instance] == n_read_temp) {
			threshold_high_shut[instance] = 0;
			fail = 1;
			strcpy(state, PSVC_ERROR);
			strcpy(fault, PSVC_TEMP_HI_SHUT);
			strcpy(led_state, PSVC_LED_ON);
			if (silent == 0)
				syslog(LOG_ERR, HIGHTEMP_CRITICAL_MSG,
				    temp, label);
		} else { /* Threshold for showing error not reached */
			return (PSVC_SUCCESS);
		}
	} else if ((features & PSVC_HIGH_WARN) && temp > hi_warn) {
		threshold_low_warn[instance] = 0;
		threshold_low_shut[instance] = 0;
		threshold_high_shut[instance] = 0;
		threshold_high_warn[instance]++;
		if (threshold_high_warn[instance] == n_read_temp) {
			threshold_high_warn[instance] = 0;
			fail = 1;
			strcpy(state, PSVC_ERROR);
			strcpy(fault, PSVC_TEMP_HI_WARN);
			strcpy(led_state, PSVC_LED_ON);
			if (silent == 0)
				syslog(LOG_ERR, HIGHTEMP_WARNING_MSG,
				    temp, label);
		} else { /* Threshold for showing error not reached */
			return (PSVC_SUCCESS);
		}
	}

	/*
	 * If we reached this point then that means that we are either
	 * okay, or we have showed error n_read_temp times.
	 */
	if (fail != 1) {
		/* within limits */
		strcpy(state, PSVC_OK);
		strcpy(fault, PSVC_NO_FAULT);
		strcpy(led_state, PSVC_LED_OFF);
	}

	status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);
	status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
	if (status != PSVC_SUCCESS)
		return (status);
	status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR,
		previous_state);
	if (status != PSVC_SUCCESS)
		return (status);

	if (strcmp(previous_state, state) != 0) {
		char *led_id;
		int32_t led_count;
		int32_t i;

		/* change state of fault LEDs */
		psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &led_count,
			PSVC_TS_OVERTEMP_LED);
		for (i = 0; i < led_count; ++i) {
			status = psvc_get_attr(hdlp, id,
				PSVC_ASSOC_ID_ATTR, &led_id,
				PSVC_TS_OVERTEMP_LED, i);
			if (status == PSVC_FAILURE)
				return (status);
			status = psvc_set_attr(hdlp, led_id,
				PSVC_LED_STATE_ATTR, led_state);
			if (status == PSVC_FAILURE)
				return (status);
		}
	}

	return (PSVC_SUCCESS);
}

int32_t
psvc_check_temperature_policy_0(psvc_opaque_t hdlp, char *id)
{
	return (check_temp(hdlp, id, 0));
}

int32_t
psvc_check_temperature_silent_policy_0(psvc_opaque_t hdlp, char *id)
{
	return (check_temp(hdlp, id, 1));
}

int32_t
psvc_fan_enable_disable_policy_0(psvc_opaque_t hdlp, char *id)
{
	char state[32], previous_state[32];
	char *backup_fan;
	int32_t status = PSVC_SUCCESS;
	uint64_t features;
	char label[32];
	boolean_t presence;
	boolean_t enable;
	int retry;

	status = psvc_get_attr(hdlp, id, PSVC_FEATURES_ATTR, &features);
	if (status != PSVC_SUCCESS)
		return (status);

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_fan_present);

		status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_fan_present) && (presence == PSVC_ABSENT));

	if (presence == PSVC_ABSENT) {
		status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_get_attr(hdlp, id, PSVC_ENABLE_ATTR, &enable);
		if (status != PSVC_SUCCESS)
			return (status);

		if (features & PSVC_DEV_PRIMARY) {
			status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
				&backup_fan, PSVC_ALTERNATE, 0);
			if (status != PSVC_SUCCESS)
				return (status);

			enable = PSVC_DISABLED;
			status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
				&enable);
			if (status != PSVC_SUCCESS)
				return (status);

			enable = PSVC_ENABLED;
			status = psvc_set_attr(hdlp, backup_fan,
				PSVC_ENABLE_ATTR, &enable);
			if (status != PSVC_SUCCESS)
				return (status);
		} else {
			enable = PSVC_DISABLED;
			status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
				&enable);
			if (status != PSVC_SUCCESS)
				return (status);
		}
		return (PSVC_SUCCESS);
	}

	/* device was present */
	status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR, state);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR, previous_state);
	if (status != PSVC_SUCCESS)
		return (status);

	if (features & PSVC_DEV_PRIMARY) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
			&backup_fan, PSVC_ALTERNATE, 0);
		if (status != PSVC_SUCCESS)
			return (status);

		if (strcmp(state, PSVC_OK) == 0) {
			enable = PSVC_ENABLED;
			status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
				&enable);
			if (status != PSVC_SUCCESS)
				return (status);

			enable = PSVC_DISABLED;
			status = psvc_set_attr(hdlp, backup_fan,
				PSVC_ENABLE_ATTR, &enable);
			if (status != PSVC_SUCCESS)
				return (status);
		}
		if ((strcmp(state, PSVC_ERROR) == 0) &&
			(strcmp(previous_state, PSVC_ERROR) != 0)) {
			enable = PSVC_DISABLED;
			status = psvc_set_attr(hdlp, id, PSVC_ENABLE_ATTR,
				&enable);
			if (status != PSVC_SUCCESS)
				return (status);

			enable = PSVC_ENABLED;
			status = psvc_set_attr(hdlp, backup_fan,
				PSVC_ENABLE_ATTR, &enable);
			if (status != PSVC_SUCCESS)
				return (status);
		}
	} else {
		if ((strcmp(state, PSVC_ERROR) == 0) &&
			(strcmp(previous_state, PSVC_ERROR) != 0)) {
			status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR,
				label);
			if (status != PSVC_SUCCESS)
				return (status);
			syslog(LOG_ERR, SECONDARY_FAN_FAIL_MSG, label);
		}
	}
	return (status);
}

/*
 * psvc_switch_fan_onoff_policy_0
 * Turn a fan on if it is enabled, turn it off if it is disabled.
 */
int32_t
psvc_switch_fan_onoff_policy_0(psvc_opaque_t hdlp, char *id)
{
	boolean_t enable;
	char *switchid;
	char state[32];
	int32_t status = PSVC_SUCCESS;

	status = psvc_get_attr(hdlp, id, PSVC_ENABLE_ATTR, &enable);
	if (status != PSVC_SUCCESS)
		return (status);

	status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &switchid,
		PSVC_FAN_ONOFF_SENSOR, 0);
	if (status != PSVC_SUCCESS)
		return (status);

	if (enable == PSVC_DISABLED) {
		strcpy(state, PSVC_SWITCH_OFF);
	} else {
		strcpy(state, PSVC_SWITCH_ON);
	}

	status = psvc_set_attr(hdlp, switchid, PSVC_SWITCH_STATE_ATTR, state);
	return (status);
}

static int32_t
check_cpu_temp_fault(psvc_opaque_t hdlp, char *cpu, int32_t cpu_count)
{
	char *sensorid;
	int32_t sensor_count;
	int32_t status = PSVC_SUCCESS;
	int32_t i;
	uint64_t features;
	char fault[32];

	status = psvc_get_attr(hdlp, cpu, PSVC_FEATURES_ATTR, &features);
	if (status == PSVC_FAILURE)
		return (status);

	psvc_get_attr(hdlp, cpu, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_TEMP_SENSOR);
	for (i = 0; i < sensor_count; ++i) {
		status = psvc_get_attr(hdlp, cpu, PSVC_ASSOC_ID_ATTR,
			&sensorid, PSVC_DEV_TEMP_SENSOR, i);
		if (status == PSVC_FAILURE)
			return (status);

		status = psvc_get_attr(hdlp, sensorid, PSVC_FAULTID_ATTR,
			fault);
		if (status == PSVC_FAILURE)
			return (status);

		if ((strcmp(fault, PSVC_TEMP_HI_SHUT) == 0) ||
			(strcmp(fault, PSVC_TEMP_LO_SHUT) == 0)) {
			if (cpu_count == 1 || cpus_online == 1 ||
			    !(features & PSVC_DEV_HOTPLUG)) {
				system(shutdown_string);
			} else {
				/* FIX offline cpu */
				--cpus_online;
			}
		}
	}

	return (status);
}

int32_t
psvc_shutdown_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t cpu_count;
	char *cpuid;
	int32_t i;
	boolean_t present;
	int32_t status = PSVC_SUCCESS;

	if (cpus_online == 0) {
		/* obviously, zero isn't correct, count present cpu's */
		psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count,
			PSVC_CPU);
		for (i = 0; i < cpu_count; ++i) {
			status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
				&cpuid, PSVC_CPU, i);
			if (status == PSVC_FAILURE)
				return (status);

			status = psvc_get_attr(hdlp, cpuid,
				PSVC_PRESENCE_ATTR, &present);
			if (status == PSVC_FAILURE && present == PSVC_PRESENT)
				return (status);
			if (present == PSVC_PRESENT)
				++cpus_online;
		}
	}
	psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &cpu_count,
		PSVC_CPU);
	for (i = 0; i < cpu_count; ++i) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR, &cpuid,
			PSVC_CPU, i);
		if (status == PSVC_FAILURE)
			return (status);
		status = check_cpu_temp_fault(hdlp, cpuid, cpu_count);
		if (status == PSVC_FAILURE && errno != ENODEV)
			return (status);
	}

	return (PSVC_SUCCESS);
}

/*
 * psvc_keyswitch_position_policy_0
 * Checks the state of the keyswitch sensors.
 * If a keyswitch position sensor's state is on, the position
 * of the key is written to syslog.  If none of the sensors
 * are on (keyswitch is not at one of the detents), a message is sent
 * to syslog stating that the position is unknown.
 */
int32_t
psvc_keyswitch_position_policy_0(psvc_opaque_t hdlp, char *id)
{
	char position[32];
	int32_t status = PSVC_SUCCESS;
	static int error_reported = 0;
	static char local_previous_position[32];
	static int32_t first_time = 1;
	int retry;

	if (first_time) {
		first_time = 0;
		status = psvc_get_attr(hdlp, id, PSVC_STATE_ATTR,
		    local_previous_position);
		if (status != PSVC_SUCCESS)
			return (status);
	}

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_keyswitch);

		status = psvc_get_attr(hdlp, id, PSVC_SWITCH_STATE_ATTR,
		    position);
		if (status != PSVC_SUCCESS)
			return (status);

		if (strcmp(position, PSVC_ERROR) == 0) {
			if ((errno == EINVAL) && (!(error_reported))) {
				syslog(LOG_ERR,
				    KEYSWITCH_POS_READ_FAILED_MSG);
				error_reported = 1;
				return (PSVC_SUCCESS);
			}
		}
		retry++;
	} while ((retry < n_retry_keyswitch) &&
	    (strcmp(position, local_previous_position) != 0));

	status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, position);
	if (status != PSVC_SUCCESS)
		return (status);

	if (strcmp(position, local_previous_position) != 0) {
		error_reported = 0;
		strcpy(local_previous_position, position);
		syslog(LOG_ERR, KEYSWITCH_POS_CHANGED_MSG, position);
	}

	return (status);
}

int32_t
psvc_hotplug_notifier_policy_0(psvc_opaque_t hdlp, char *id)
{
	boolean_t presence, previous_presence;
	int32_t status = PSVC_SUCCESS;
	char label[32];
	int retry;

	status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR,
		&previous_presence);
	if (status != PSVC_SUCCESS)
		return (status);

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_hotplug);
		status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_hotplug) &&
	    (presence != previous_presence));


	if (presence != previous_presence) {
		char parent_path[256];
		picl_nodehdl_t child_node;

		status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
		if (status != PSVC_SUCCESS)
			return (status);

		/* return parent path and node for an object */
		psvcplugin_lookup(id, parent_path, &child_node);

		if (presence == PSVC_PRESENT) {
			char state[32], fault[32];
			picl_nodehdl_t parent_node;

			syslog(LOG_ERR, DEVICE_INSERTED_MSG, label);
			strcpy(state, PSVC_OK);
			status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
				state);
			if (status != PSVC_SUCCESS)
				return (status);
			strcpy(fault, PSVC_NO_FAULT);
			status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
				fault);
			if (status != PSVC_SUCCESS) {
				return (status);
			}

			status = ptree_get_node_by_path(parent_path,
				&parent_node);
			if (status != 0)
				return (PSVC_FAILURE);
			status = ptree_add_node(parent_node, child_node);
			if (status != 0)
				return (PSVC_FAILURE);
		} else {
			syslog(LOG_ERR, DEVICE_REMOVED_MSG, label);

			ptree_delete_node(child_node);

		}
	}

	status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
	if (status != PSVC_SUCCESS)
		return (status);

	return (status);
}

int32_t
psvc_fan_hotplug_policy_0(psvc_opaque_t hdlp, char *id)
{
	boolean_t presence, previous_presence;
	int32_t status = PSVC_SUCCESS;
	char label[32];
	int retry;

	status = psvc_get_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR,
		&previous_presence);
	if (status != PSVC_SUCCESS)
		return (status);

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_fan_hotplug);

		status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_fan_hotplug) &&
	    (presence != previous_presence));


	if (presence != previous_presence) {
		char parent_path[256];
		picl_nodehdl_t child_node;

		status = psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, label);
		if (status != PSVC_SUCCESS)
			return (status);

		/* return parent path and node for an object */
		psvcplugin_lookup(id, parent_path, &child_node);

		if (presence == PSVC_PRESENT) {
			char state[32], fault[32];
			char *slot_id;
			char *led_id;
			int32_t i, led_count;
			char led_state[32];
			picl_nodehdl_t parent_node;

			syslog(LOG_ERR, DEVICE_INSERTED_MSG, label);

			strcpy(state, PSVC_OK);
			status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR,
				state);
			if (status != PSVC_SUCCESS)
				return (status);
			strcpy(fault, PSVC_NO_FAULT);
			status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR,
				fault);
			if (status != PSVC_SUCCESS)
				return (status);

			/* turn off fault LEDs */
			psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
				&led_count, PSVC_DEV_FAULT_LED);
			strcpy(led_state, PSVC_LED_OFF);
			for (i = 0; i < led_count; ++i) {
				status = psvc_get_attr(hdlp, id,
					PSVC_ASSOC_ID_ATTR, &led_id,
					PSVC_DEV_FAULT_LED, i);
				if (status == PSVC_FAILURE)
					return (status);
				status = psvc_set_attr(hdlp, led_id,
					PSVC_LED_STATE_ATTR, led_state);
				if (status == PSVC_FAILURE)
					return (status);
			}

			/* turn off OK to remove LEDs */
			status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
				&slot_id, PSVC_PARENT, 0);
			if (status != PSVC_SUCCESS)
				return (status);

			psvc_get_attr(hdlp, slot_id, PSVC_ASSOC_MATCHES_ATTR,
				&led_count, PSVC_SLOT_REMOVE_LED);
			strcpy(led_state, PSVC_LED_OFF);
			for (i = 0; i < led_count; ++i) {
				status = psvc_get_attr(hdlp, slot_id,
					PSVC_ASSOC_ID_ATTR, &led_id,
					PSVC_SLOT_REMOVE_LED, i);
				if (status == PSVC_FAILURE)
					return (status);

				status = psvc_set_attr(hdlp, led_id,
					PSVC_LED_STATE_ATTR, led_state);
				if (status == PSVC_FAILURE)
					return (status);
			}

			ptree_get_node_by_path(parent_path, &parent_node);
			ptree_add_node(parent_node, child_node);
		} else {
			syslog(LOG_ERR, DEVICE_REMOVED_MSG, label);
			ptree_delete_node(child_node);
		}
	}

	status = psvc_set_attr(hdlp, id, PSVC_PREV_PRESENCE_ATTR, &presence);
	if (status != PSVC_SUCCESS)
		return (status);

	return (status);
}

int32_t
psvc_init_led_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t status;

	status = psvc_set_attr(hdlp, id, PSVC_LED_STATE_ATTR, PSVC_LED_OFF);
	return (status);
}

int32_t
psvc_init_state_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t status;

	status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, PSVC_OK);
	status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, PSVC_NO_FAULT);
	return (status);
}

int32_t
psvc_ps_overcurrent_check_policy_0(psvc_opaque_t hdlp, char *power_supply_id)
{
	int32_t status = PSVC_SUCCESS;
	boolean_t present;
	char *sensor_id;
	int32_t sensor_count;
	int32_t i;
	int32_t amps, hi_warn;

	status = psvc_get_attr(hdlp, power_supply_id, PSVC_PRESENCE_ATTR,
		&present);
	if (status == PSVC_FAILURE) {
		syslog(LOG_ERR, GET_PRESENCE_FAILED_MSG, power_supply_id,
			errno);
		return (status);
	}

	if (present == PSVC_ABSENT) {
		errno = ENODEV;
		return (PSVC_FAILURE);
	}

	psvc_get_attr(hdlp, power_supply_id, PSVC_ASSOC_MATCHES_ATTR,
		&sensor_count, PSVC_PS_I_SENSOR);
	for (i = 0; i < sensor_count; ++i) {
		status = psvc_get_attr(hdlp, power_supply_id,
			PSVC_ASSOC_ID_ATTR, &sensor_id, PSVC_PS_I_SENSOR, i);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_get_attr(hdlp, sensor_id, PSVC_HI_WARN_ATTR,
			&hi_warn);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_get_attr(hdlp, sensor_id,
			PSVC_SENSOR_VALUE_ATTR, &amps);
		if (status != PSVC_SUCCESS) {
			syslog(LOG_ERR, GET_SENSOR_FAILED_MSG, sensor_id,
				errno);
			return (status);
		}

		if (amps >= hi_warn) {
			char label[32];

			status = psvc_get_attr(hdlp, power_supply_id,
				PSVC_LABEL_ATTR, &label);
			if (status != PSVC_SUCCESS)
				return (status);

			syslog(LOG_ERR, PS_OVER_CURRENT_MSG, label);
		}
	}

	return (PSVC_SUCCESS);

}

int32_t
psvc_device_fail_notifier_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t led_count, sensor_count;
	char *led_id, *sensor_id;
	int i;
	char state[32], fault[32], previous_state[32];
	char led_state[32];
	int32_t status = PSVC_SUCCESS;
	boolean_t present;

	status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &present);
	if (status == PSVC_FAILURE)
		return (status);

	if (present == PSVC_ABSENT) {
		errno = ENODEV;
		return (PSVC_FAILURE);
	}

	psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_FAULT_SENSOR);
	for (i = 0; i < sensor_count; ++i) {
		status = psvc_get_attr(hdlp, id, PSVC_ASSOC_ID_ATTR,
			&sensor_id, PSVC_DEV_FAULT_SENSOR, i);
		if (status != PSVC_SUCCESS)
			return (status);

		status = psvc_get_attr(hdlp, sensor_id,
			PSVC_SWITCH_STATE_ATTR, state);
		if (status != PSVC_SUCCESS)
			return (status);

		if (strcmp(state, PSVC_SWITCH_ON) == 0) {
			strcpy(state, PSVC_ERROR);
			strcpy(fault, PSVC_GEN_FAULT);
		} else {
			strcpy(state, PSVC_OK);
			strcpy(fault, PSVC_NO_FAULT);
		}

		status = psvc_set_attr(hdlp, id, PSVC_STATE_ATTR, state);
		if (status != PSVC_SUCCESS)
			return (status);
		status = psvc_set_attr(hdlp, id, PSVC_FAULTID_ATTR, fault);
		if (status != PSVC_SUCCESS)
			return (status);
		status = psvc_get_attr(hdlp, id, PSVC_PREV_STATE_ATTR,
			previous_state);
		if (status != PSVC_SUCCESS)
			return (status);

		if (strcmp(state, previous_state) != 0) {
			char sensor_label[32];
			char dev_label[32];
			int32_t j;

			psvc_get_attr(hdlp, id, PSVC_LABEL_ATTR, dev_label);
			psvc_get_attr(hdlp, sensor_id, PSVC_LABEL_ATTR,
				sensor_label);

			if (strcmp(state, PSVC_ERROR) == 0) {
				syslog(LOG_ERR, DEVICE_FAILURE_MSG, dev_label,
					sensor_label);
				strcpy(led_state, PSVC_LED_ON);
			} else {
				syslog(LOG_ERR, DEVICE_OK_MSG, dev_label);
				strcpy(led_state, PSVC_LED_OFF);
			}

			psvc_get_attr(hdlp, id, PSVC_ASSOC_MATCHES_ATTR,
				&led_count, PSVC_DEV_FAULT_LED);
			for (j = 0; j < led_count; j++) {
				status = psvc_get_attr(hdlp, id,
					PSVC_ASSOC_ID_ATTR, &led_id,
					PSVC_DEV_FAULT_LED, j);
				if (status != PSVC_SUCCESS)
					return (status);
				status = psvc_set_attr(hdlp, led_id,
					PSVC_LED_STATE_ATTR, led_state);
				if (status != PSVC_SUCCESS) {
					syslog(LOG_ERR, SET_LED_FAILED_MSG,
						led_id, errno);
					return (status);
				}
			}
		}
	}

	return (PSVC_SUCCESS);
}

static float
get_filtered_error(float *last_errors, int current_error)
{
	float error;
	float adder;
	int i = 0;

	adder = last_errors[0];
	for (i = 1; i < PSVC_MAXERRORS; i++) {
		adder = adder + last_errors[i];
	}
	adder = adder + current_error;
	error = adder/(PSVC_MAXERRORS+1);

	return (error);
}

static int32_t
change_cpu_fans(psvc_opaque_t hdlp, char *fan_id, int32_t fan_speed)
{
	int err = PSVC_SUCCESS;
	int i;
	int32_t control_count;
	char *control_id;
	int32_t old_fan_speed;

	psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_MATCHES_ATTR, &control_count,
		PSVC_FAN_DRIVE_CONTROL);
	if (control_count == 0)
		return (PSVC_SUCCESS);

	err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR, &control_id,
		PSVC_FAN_DRIVE_CONTROL, 0);
	if (err != PSVC_SUCCESS)
		return (err);

	/*
	 * this call will return PSVC_FAILURE on the first pass,
	 * because no value has been set.
	 */
	err = psvc_get_attr(hdlp, control_id, PSVC_CONTROL_VALUE_ATTR,
		&old_fan_speed);
	if (err == PSVC_SUCCESS && old_fan_speed == fan_speed)
		return (PSVC_SUCCESS);

	for (i = 0; i < control_count; i++) {
		err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR,
			&control_id, PSVC_FAN_DRIVE_CONTROL, i);
		if (err != PSVC_SUCCESS)
			return (err);

		err = psvc_set_attr(hdlp, control_id, PSVC_CONTROL_VALUE_ATTR,
			&fan_speed);
		if (err == PSVC_FAILURE) {
			syslog(LOG_ERR, SET_FANSPEED_FAILED_MSG, control_id,
				errno);
			return (err);
		}
	}
	return (err);
}

static int32_t
device_temp_check(psvc_opaque_t hdlp, char *fan_id, int32_t *hot_device)
{
	int i;
	int32_t err = PSVC_SUCCESS;
	char *sensor_id;
	int32_t sensor_count;
	int32_t temp;

	*hot_device = 0;

	psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_MATCHES_ATTR, &sensor_count,
		PSVC_DEV_TEMP_SENSOR);
	for (i = 0; i < sensor_count; i++) {
		err = psvc_get_attr(hdlp, fan_id, PSVC_ASSOC_ID_ATTR,
			&sensor_id, PSVC_DEV_TEMP_SENSOR, i);
		if (err == PSVC_FAILURE)
			return (err);
		err = psvc_get_attr(hdlp, sensor_id, PSVC_SENSOR_VALUE_ATTR,
			&temp);
		if (err == PSVC_FAILURE) {
			if (errno == ENODEV) {
				temp = 0;
			} else {
				syslog(LOG_ERR, GET_SENSOR_FAILED_MSG,
				    sensor_id, errno);
				return (err);
			}
		}

		if (*hot_device < temp)
			*hot_device = temp;
	}
	return (PSVC_SUCCESS);
}

int32_t
psvc_fan_control_policy_0(psvc_opaque_t hdlp, char *fan_id)
{
	boolean_t is_enabled;
	int32_t err = PSVC_SUCCESS;
	int16_t setpoint, hysteresis, loopgain, loopbias;
	int current_error;		/* Holds current error */
					/* Signal before signaling */
	float filtered_error;		/* Holds the filtered error signal */
	int ampout;			/* output of loop amplifier */
	int hot_device;

	int16_t error_number;
	float last_errors[PSVC_MAXERRORS];	/* Holds the filtered error */
						/* from the last n iterations */

	psvc_get_attr(hdlp, fan_id, PSVC_ENABLE_ATTR, &is_enabled);
	if (is_enabled == PSVC_DISABLED)
		return (PSVC_SUCCESS);

	err = psvc_get_attr(hdlp, fan_id, PSVC_SETPOINT_ATTR, &setpoint);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, fan_id, PSVC_HYSTERESIS_ATTR,
		&hysteresis);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, fan_id, PSVC_LOOPGAIN_ATTR, &loopgain);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, fan_id, PSVC_LOOPBIAS_ATTR, &loopbias);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_ATTR,
		last_errors);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_get_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_INDEX_ATTR,
		&error_number);
	if (err != PSVC_SUCCESS)
		return (err);

	err = device_temp_check(hdlp, fan_id, &hot_device);
	if (err != PSVC_SUCCESS) {
		printf("psvc_fan_control failure in device_temp_check\n");
		return (err);
	}
	current_error = setpoint - hot_device;
	filtered_error = get_filtered_error(last_errors, current_error);
	if (filtered_error <= 0 || filtered_error > hysteresis) {
		ampout = (int)((filtered_error * loopgain) + loopbias);
		if (ampout < 0)
			ampout = 0;
		if (ampout > 1023)
			ampout = 1023;
		err = change_cpu_fans(hdlp, fan_id, ampout);
		if (err != PSVC_SUCCESS)
			return (err);
	}
	last_errors[error_number++] = current_error;
	if (error_number == PSVC_MAXERRORS)
		error_number = 0;

	err = psvc_set_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_ATTR,
		last_errors);
	if (err != PSVC_SUCCESS)
		return (err);

	err = psvc_set_attr(hdlp, fan_id, PSVC_TEMP_DIFFERENTIAL_INDEX_ATTR,
		&error_number);
	if (err != PSVC_SUCCESS)
		return (err);

	return (PSVC_SUCCESS);
}

int32_t
psvc_fan_present_policy_0(psvc_opaque_t hdlp, char *id)
{
	int32_t		status = PSVC_SUCCESS;
	boolean_t	presence;
	int fd;
	FILE *fp;
	int retry;

	retry = 0;
	do {
		if (retry)
			(void) sleep(retry_sleep_fan_present);

		status = psvc_get_attr(hdlp, id, PSVC_PRESENCE_ATTR, &presence);
		if (status != PSVC_SUCCESS)
			return (status);
		retry++;
	} while ((retry < n_retry_fan_present) && (presence == PSVC_ABSENT));

	if (presence == PSVC_ABSENT) {
		/*
		 * We make this open, write, close, call because picld
		 * starts in rcS.d while print services does not start
		 * until later (either rc2.d or rc3.d)
		 */
		fd = open("/dev/console", O_WRONLY | O_NOCTTY);
		if (fd != -1) {
			fp = fdopen(fd, "w+");
			if (fp != NULL) {
				fprintf(fp, FAN_MISSING_MSG, id);
				fclose(fp);
			}
			close(fd);
		}
		syslog(LOG_ERR, FAN_MISSING_MSG, id);
	}
	return (status);
}