xref: /illumos-gate/usr/src/cmd/picl/plugins/sun4u/psvc/psvcplugin/psvcplugin.c (revision afe82bdc)

/*
 * 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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * PICL plug-in to create environment tree nodes.
 * This plugin should only be installed in the platform directories
 * of supported systems, such as /usr/platform/picl/plugins/SUNW,<>.
 */

#include <picl.h>
#include <picltree.h>
#include <stdio.h>
#include <time.h>
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <limits.h>
#include  <ctype.h>
#include <pthread.h>
#include <libintl.h>
#include <errno.h>
#include <semaphore.h>
#include <sched.h>
#include <syslog.h>
#include <string.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/systeminfo.h>
#include <psvc_objects.h>
#include <psvc_objects_class.h>

#define	BUFSZ	512

typedef struct {
	char	name[32];
} EName_t;

typedef struct {
	void *hdl;
	int32_t (*funcp)(void *, char *);
	int32_t	num_objects;
	EName_t *obj_list;
	char    routine[64];
} ETask_t;

typedef struct interval_info {
	volatile int32_t   interval;
	int32_t	  num_tasks;
	ETask_t   *task_list;
	pthread_t thread;
	int32_t   has_thread;
	struct interval_info *next;
} EInterval_t;

static EInterval_t *first_interval;

static psvc_opaque_t hdlp;

sem_t timer_sem;
pthread_mutex_t timer_mutex;
pthread_cond_t timer_cond;
pthread_t timer_thread_id;

extern int ptree_get_node_by_path(const char *, picl_nodehdl_t *);

/* Timer states */
#define	NOT_READY	0
#define	READY		1
#define	HAVE_REQUEST	2
#define	ACTIVE		3
#define	TIMER_SHUTDOWN	4

int timer_state = NOT_READY;

int app_timeout;

/* Lock State Loop State Definitions */
#define	STATE_CHANGED		1
#define	STATE_NOT_CHANGED	0

#ifdef DEBUG
static int32_t debug_flag = 1;
#else
static int32_t debug_flag = 0;
#endif

static char library[PATH_MAX];

#define	PSVC_PLUGIN_VERSION	PICLD_PLUGIN_VERSION_1

#pragma init(psvc_plugin_register)	/* place in .init section */

typedef struct  {
	char	parent_path[256];
	char    child_name[32];
	picl_nodehdl_t	child_node;
} psvc_name_t;
psvc_name_t *psvc_paths;

#define	MUTEX_LOCK_FAILED_MSG	gettext("platsvcd: pthread_mutex_lock %s\n")
#define	CV_WAIT_FAILED_MSG	gettext("platsvcd: pthread_cond_wait %s\n")
#define	CV_TWAIT_FAILED_MSG gettext("platsvcd: pthread_cond_timed_wait %s\n")
#define	SEM_WAIT_FAILED_MSG	gettext("platsvcd: sem_wait failed %s\n")
#define	PSVC_APP_DEATH_MSG	gettext("PSVC application death detected\n")
#define	POLICY_FAILED_MSG	gettext("ERROR running %s on %s (%d)")
#define	ID_NOT_FOUND_MSG	gettext("%s: Can't determine id of %s\n")
#define	CLASS_NOT_FOUND_MSG	gettext("%s: Can't determine class of %s\n")
#define	SUBCLASS_NOT_FOUND_MSG	gettext("%s: Can't determine subclass of %s\n")
#define	NODE_NOT_FOUND_MSG	gettext("%s: Can't determine node of %s\n")
#define	SIZE_NOT_FOUND_MSG	gettext("%s: Couldn't determine size of %s\n")
#define	PTREE_CREATE_TABLE_FAILED_MSG		\
	gettext("%s: ptree_create_table failed, %s\n")
#define	PTREE_CREATE_PROP_FAILED_MSG		\
	gettext("%s: ptree_create_prop failed, %s\n")
#define	PTREE_CREATE_NODE_FAILED_MSG		\
	gettext("%s: ptree_create_node failed, %s\n")
#define	PTREE_ADD_ROW_FAILED_MSG gettext("%s: ptree_add_row_to_table: %s\n")
#define	PTREE_ADD_NODE_FAILED_MSG gettext("%s: ptree_add_node: %s\n")
#define	PTREE_ADD_PROP_FAILED_MSG gettext("%s: ptree_add_prop: %s\n")
#define	PTREE_GET_ROOT_FAILED_MSG gettext("%s: ptree_get_root: %s\n")
#define	CREATE_PROP_FAILED_MSG	gettext("%s: Error creating property %s\n")
#define	INVALID_FILE_FORMAT_MSG		gettext("%s: Invalid file format\n")
#define	INVALID_FILE_FORMAT1_MSG	gettext("%s: Invalid file format %s\n")
#define	PSVC_INIT_ERR_MSG	gettext("%s: Error in psvc_init(): %s\n")
#define	SYSINFO_FAILED_MSG	gettext("%s: Can't determine platform type\n")
#define	FILE_OPEN_FAILED_MSG	gettext("%s: Can't open file %s\n")
#define	MALLOC_FAILED_MSG	gettext("%s: malloc failed, %s\n")
#define	UNKNOWN_CLASS_MSG	gettext("%s: Unknown class\n")
#define	NODE_PROP_FAILED_MSG	gettext("%s: node_property: %s\n")

#define	LOCK_STRING_MAX 32

picl_nodehdl_t system_node;
static picl_nodehdl_t lock_node;
static char env_lock_state[LOCK_STRING_MAX] = PSVC_LOCK_ENABLED;
static pthread_mutex_t env_lock_mutex;

static char *class_name[] = {
"temperature-sensor",
"fan",
"led",
"picl",
"digital-sensor",
"digital-control",
"gpio",
"fan-tachometer",
"switch",
"keyswitch",
"gpio",
"i2c"
};
#define	NUM_CLASSES (sizeof (class_name) / sizeof (char *))

struct proj_prop {	/* projected property */
	picl_prophdl_t	handle;
	picl_nodehdl_t  dst_node;
	char		name[32];
};

struct propinfo {
	char		*name;
	uint32_t	type;
	uint32_t	size;
	uint32_t	access;
};

struct propinfo common[] = {
	{"State", PICL_PTYPE_CHARSTRING, 32,
	PICL_READ | PICL_WRITE | PICL_VOLATILE},
	{"FaultInformation", PICL_PTYPE_CHARSTRING, 32,
	PICL_READ | PICL_VOLATILE}
};
#define	COMMON_COUNT (sizeof (common) / sizeof (struct propinfo))

struct propinfo led_properties[] = {
	{"Color", PICL_PTYPE_CHARSTRING, 32, PICL_READ | PICL_VOLATILE},
	{"IsLocator", PICL_PTYPE_CHARSTRING, 32, PICL_READ | PICL_VOLATILE},
	{"LocatorName", PICL_PTYPE_CHARSTRING, 32, PICL_READ | PICL_VOLATILE}
};
/*
 * We define the amount of LED properties to 1 because not all LED's have
 * the two remainding properties.  This number is augmented in psvc_plugin_init
 * when it sees an LED of subclass 2.
 */
#define	LED_COUNT 1

struct propinfo temperature_sensor_properties[] = {
	{"Temperature", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"LowWarningThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"LowShutdownThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"HighWarningThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"HighShutdownThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE}
};
#define	TEMP_SENSOR_COUNT \
	(sizeof (temperature_sensor_properties) / sizeof (struct propinfo))

struct propinfo digi_sensor_properties[] = {
	{"AtoDSensorValue", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"LowWarningThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"LowShutdownThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"HighWarningThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE},
	{"HighShutdownThreshold", PICL_PTYPE_INT, 4, PICL_READ | PICL_VOLATILE}
};
#define	DIGI_SENSOR_COUNT \
	(sizeof (digi_sensor_properties) / sizeof (struct propinfo))

struct propinfo boolgpio_properties[] = {
	{"Gpio-value", PICL_PTYPE_UNSIGNED_INT, sizeof (boolean_t),
	PICL_READ | PICL_WRITE | PICL_VOLATILE},
	{"#Bits", PICL_PTYPE_UNSIGNED_INT, 4, PICL_READ |PICL_VOLATILE}
};
#define	BOOLGPIO_COUNT (sizeof (boolgpio_properties) / sizeof (struct propinfo))

struct propinfo gpio8_properties[] = {
	{"Gpio-value", PICL_PTYPE_UNSIGNED_INT, 1,
	PICL_READ | PICL_WRITE | PICL_VOLATILE},
	{"#Bits", PICL_PTYPE_UNSIGNED_INT, 4, PICL_READ |PICL_VOLATILE}
};
#define	GPIO8_COUNT (sizeof (gpio8_properties) / sizeof (struct propinfo))

struct propinfo digictrl_properties[] = {
	{"DtoAControlValue", PICL_PTYPE_INT, 4,
	PICL_READ | PICL_WRITE | PICL_VOLATILE},
};
#define	DIGICTRL_COUNT (sizeof (digictrl_properties) / sizeof (struct propinfo))

struct classinfo {
	struct propinfo	*props;
	int32_t		count;
} class_properties[] =
{
	{temperature_sensor_properties, TEMP_SENSOR_COUNT}, /* temp sensor */
	{0, 0},				/* fan, only has projected properties */
	{led_properties, LED_COUNT},
	{0, 0},						  /* system class */
	{digi_sensor_properties, DIGI_SENSOR_COUNT}, /* digital sensor */
	{digictrl_properties, DIGICTRL_COUNT},
	{boolgpio_properties, BOOLGPIO_COUNT},
	{digi_sensor_properties, DIGI_SENSOR_COUNT}, /* fan tach */
	{0, 0},
	{0, 0},
	{gpio8_properties, GPIO8_COUNT},
	{0, 0},
};

struct prop_trans {
	char *picl_class;
	char *picl_prop;
	int32_t psvc_prop;
} picl_prop_trans[] =
{
	{"digital-sensor", "AtoDSensorValue", PSVC_SENSOR_VALUE_ATTR},
	{"digital-sensor", "LowWarningThreshold", PSVC_LO_WARN_ATTR},
	{"digital-sensor", "LowShutdownThreshold", PSVC_LO_SHUT_ATTR},
	{"digital-sensor", "HighWarningThreshold", PSVC_HI_WARN_ATTR},
	{"digital-sensor", "HighShutdownThreshold", PSVC_HI_SHUT_ATTR},
	{"digital-control", "DtoAControlValue", PSVC_CONTROL_VALUE_ATTR},
	{"fan-tachometer", "AtoDSensorValue", PSVC_SENSOR_VALUE_ATTR},
	{"fan-tachometer", "LowWarningThreshold", PSVC_LO_WARN_ATTR},
	{"fan-tachometer", "LowShutdownThreshold", PSVC_LO_SHUT_ATTR},
	{"fan-tachometer", "HighWarningThreshold", PSVC_HI_WARN_ATTR},
	{"fan-tachometer", "HighShutdownThreshold", PSVC_HI_SHUT_ATTR},
	{"temperature-sensor", "Temperature", PSVC_SENSOR_VALUE_ATTR},
	{"temperature-sensor", "LowWarningThreshold", PSVC_LO_WARN_ATTR},
	{"temperature-sensor", "LowShutdownThreshold", PSVC_LO_SHUT_ATTR},
	{"temperature-sensor", "HighWarningThreshold", PSVC_HI_WARN_ATTR},
	{"temperature-sensor", "HighShutdownThreshold", PSVC_HI_SHUT_ATTR},
	{"led", "State", PSVC_LED_STATE_ATTR},
	{"led", "Color", PSVC_LED_COLOR_ATTR},
	{"switch", "State", PSVC_SWITCH_STATE_ATTR},
	{"keyswitch", "State", PSVC_SWITCH_STATE_ATTR},
	{"i2c", "State", PSVC_PROBE_RESULT_ATTR}
};

#define	PICL_PROP_TRANS_COUNT \
	(sizeof (picl_prop_trans) / sizeof (struct prop_trans))


typedef struct {
	char		name[32];
	picl_nodehdl_t	node;
} picl_psvc_t;

struct assoc_pair {
	char	antecedent[32];
	char	dependent[32];
};

struct handle {
	uint32_t    obj_count;
	picl_psvc_t *objects;
	FILE	*fp;
} psvc_hdl;

struct proj_prop *prop_list;
uint32_t proj_prop_count;

int psvc_picl_nodes;

void psvc_plugin_init(void);
void psvc_plugin_fini(void);

picld_plugin_reg_t psvc_reg = {
	PSVC_PLUGIN_VERSION,
	PICLD_PLUGIN_CRITICAL,
	"PSVC",
	psvc_plugin_init,
	psvc_plugin_fini
};

/*
 * psvcplugin_add_children was written so that devices which are hotplugable
 * will be able to add in all thier children and children's children. The
 * routine takes in the path of a parent and then searches the psvc_paths
 * array to find all of it's children.  It in turns adds the child and then
 * recursively check to see if it had children and add them too.
 */
void
psvcplugin_add_children(char *parent_path)
{
	int i;
	picl_nodehdl_t parent_node;
	char next_path[256];

	for (i = 0; i < psvc_picl_nodes; ++i) {
		if (strcmp(parent_path, psvc_paths[i].parent_path) == 0) {
			ptree_get_node_by_path(parent_path, &parent_node);
			ptree_add_node(parent_node, psvc_paths[i].child_node);
			(void) snprintf(next_path, sizeof (next_path), "%s/%s",
			    parent_path, psvc_paths[i].child_name);
			psvcplugin_add_children(next_path);
		}
	}
}

void
psvcplugin_lookup(char *name, char *parent, picl_nodehdl_t *node)
{
	int i;

	for (i = 0; i < psvc_picl_nodes; ++i) {
		if (strcmp(name, psvc_paths[i].child_name) == 0) {
			(void) strcpy(parent, psvc_paths[i].parent_path);
			*node = psvc_paths[i].child_node;
		}
	}
}

void
timer_thread(void)
{
	struct timespec timeout;
	int status;


	status = pthread_mutex_lock(&timer_mutex);
	if (status != 0) {
		syslog(LOG_ERR, MUTEX_LOCK_FAILED_MSG, strerror(status));
	}

	for (;;) {
		/* wait for thread to tell us to start timer */
		timer_state = READY;
		do {
			status = pthread_cond_wait(&timer_cond, &timer_mutex);
		} while (timer_state == READY && status == 0);

		if (timer_state == TIMER_SHUTDOWN) {
			pthread_exit(NULL);
			/* not reached */
		}

		if (status != 0) {
			syslog(LOG_ERR, CV_WAIT_FAILED_MSG, strerror(status));
		}

		/*
		 * Will get signalled after semaphore acquired,
		 * or when timeout occurs.
		 */
		(void) clock_gettime(CLOCK_REALTIME, &timeout);
		timeout.tv_sec += app_timeout;

		if (timer_state == HAVE_REQUEST) {
			timer_state = ACTIVE;
			do {
				status = pthread_cond_timedwait(&timer_cond,
				    &timer_mutex, &timeout);
			} while (timer_state == ACTIVE && status == 0);
		}

		if (status != 0) {
			if (status == ETIMEDOUT) {
				syslog(LOG_ERR, PSVC_APP_DEATH_MSG);
				(void) pthread_mutex_lock(&env_lock_mutex);
				(void) strlcpy(env_lock_state,
				    PSVC_LOCK_ENABLED, LOCK_STRING_MAX);
				(void) pthread_mutex_unlock(&env_lock_mutex);
			} else {
				syslog(LOG_ERR, CV_TWAIT_FAILED_MSG,
				    strerror(status));
			}
		}
	}
}

static int
lock_state_loop(char *set_lock_state)
{
	(void) pthread_mutex_lock(&env_lock_mutex);
	if (strcmp(env_lock_state, PSVC_LOCK_ENABLED) == 0) {
		(void) strlcpy(env_lock_state, set_lock_state, LOCK_STRING_MAX);
		(void) pthread_mutex_unlock(&env_lock_mutex);
		return (STATE_NOT_CHANGED);
	}
	(void) pthread_mutex_unlock(&env_lock_mutex);
	return (STATE_CHANGED);
}

static int timed_lock_wait(char *set_lock_state)
{
	int32_t status;

	/* Only want one timer active at a time */
	do {
		status = sem_wait(&timer_sem);
	} while (status == -1 && errno == EINTR);
	if (status == -1)
		return (status);

	while (timer_state != READY)
		(void) sched_yield();
	(void) pthread_mutex_lock(&timer_mutex);
	timer_state = HAVE_REQUEST;
	(void) pthread_cond_signal(&timer_cond);	/* start timer */
	(void) pthread_mutex_unlock(&timer_mutex);

	/*
	 * We now spin checking the state env_lock_state for it to change to
	 * enabled.
	 */
	while (lock_state_loop(set_lock_state))
		(void) sleep(1);

	(void) pthread_mutex_lock(&timer_mutex);
	if (timer_state == ACTIVE) {
		timer_state = NOT_READY;
		(void) pthread_cond_signal(&timer_cond);	/* stop timer */
	}
	if (timer_state == HAVE_REQUEST) {		/* cancel request */
		timer_state = NOT_READY;
	}
	(void) pthread_mutex_unlock(&timer_mutex);
	(void) sem_post(&timer_sem);
	return (0);
}

static void lock_and_run(ETask_t *tp, int32_t obj_num)
{
	int32_t status;

	/* Grab mutex to stop the env_lock from being changed. */
	(void) pthread_mutex_lock(&env_lock_mutex);
	/*
	 * Check to see if the lock is anything but Enabled. If so, we then
	 * goto our timer routine to wait for it to become enabled.
	 * If not then set it to RUNNING and run policy.
	 */
	if (strcmp(env_lock_state, PSVC_LOCK_ENABLED) != 0) {
		/* drop mutex and goto timer */
		(void) pthread_mutex_unlock(&env_lock_mutex);
		status = timed_lock_wait(PSVC_LOCK_RUNNING);
		if (status == -1) {
			syslog(LOG_ERR, SEM_WAIT_FAILED_MSG);
		}
	} else {
		(void) strlcpy(env_lock_state, PSVC_LOCK_RUNNING,
		    LOCK_STRING_MAX);
		(void) pthread_mutex_unlock(&env_lock_mutex);
	}
	status = (*tp->funcp)(hdlp, (tp->obj_list + obj_num)->name);
	if (status == PSVC_FAILURE && errno != ENODEV) {
		char dev_name[32];

		psvc_get_attr(hdlp, (tp->obj_list + obj_num)->name,
		    PSVC_LABEL_ATTR, dev_name);
		syslog(LOG_ERR, POLICY_FAILED_MSG, tp->routine, dev_name,
		    (tp->obj_list + obj_num)->name);
		syslog(LOG_ERR, "%s", strerror(errno));
	}

	/* The policy is done so set the lock back to ENABLED. */
	(void) pthread_mutex_lock(&env_lock_mutex);
	(void) strlcpy(env_lock_state, PSVC_LOCK_ENABLED, LOCK_STRING_MAX);
	(void) pthread_mutex_unlock(&env_lock_mutex);
}

static void *
run_policies(void *ptr)
{
	EInterval_t *ip = ptr;
	ETask_t *tp;
	int32_t i, j;

	do {
		if (ip->interval) {
			int remaining = ip->interval;
			do {
				/* check to see if we've been told to exit */
				if (ip->has_thread && (ip->interval == 0))
					break;
				remaining = sleep(remaining);
			} while (remaining > 0);
		}
		for (i = 0; i < ip->num_tasks; ++i) {
			tp = &ip->task_list[i];
			for (j = 0; j < tp->num_objects; ++j) {
				/* check to see if we've been told to exit */
				if (ip->has_thread && (ip->interval == 0))
					break;
				lock_and_run(tp, j);
			}
			if (ip->has_thread && (ip->interval == 0))
				break;
		}
	} while (ip->interval);

	return (NULL);
}

static void thread_setup(EInterval_t *ip)
{
	int32_t status;

	status = pthread_create(&ip->thread, NULL, run_policies, ip);
	if (status != 0) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		exit(-1);
	}
	ip->has_thread = 1;
}

static int32_t load_policy(const char *library, ETask_t *tp)
{
	tp->hdl = dlopen(library, RTLD_NOW | RTLD_GLOBAL);
	if (tp->hdl == NULL) {
		if (debug_flag) {
			char *errstr = dlerror();
			syslog(LOG_ERR, "%s", errstr);
		}
		exit(1);
	}
	tp->funcp = (int32_t (*)(void *, char *))dlsym(tp->hdl, tp->routine);
	if (tp->funcp == NULL) {
		if (debug_flag) {
			char *errstr = dlerror();
			syslog(LOG_ERR, "%s", errstr);
		}
		exit(1);
	}
	return (0);
}

static int32_t get_timeout(FILE *fp, int *timeout)
{
	char buf[BUFSZ];
	char name[32];
	char *cp;

	/* skip blank lines */
	do {
		cp = fgets(buf, BUFSZ, fp);
		if (cp == NULL)
			return (1);
		while (isspace(*cp))
			++cp;
		(void) sscanf(buf, "%31s %d", name, timeout);
	} while (*cp == 0 || *cp == '\n' || strcmp(name, "TIMEOUT") != 0);

	if (strcmp(name, "TIMEOUT") != 0) {
		errno = EINVAL;
		return (-1);
	}
	return (0);

}

static int32_t load_interval(FILE *fp, EInterval_t **ipp)
{
	char buf[BUFSZ];
	int32_t found;
	EInterval_t *ip;
	ETask_t *tp;
	int32_t tasks;
	int32_t status, i, j;
	int32_t interval;
	char name[32];
	char *cp;

	/* skip blank lines */
	do {
		cp = fgets(buf, BUFSZ, fp);
		if (cp == NULL)
			return (1);
		while (isspace(*cp))
			++cp;
	} while (*cp == 0 || *cp == '\n');
	found = sscanf(buf, "%31s %d %d", name, &interval, &tasks);
	if (found != 3) {
		errno = EINVAL;
		return (-1);
	}

	if (strcmp(name, "INTERVAL") != 0) {
		errno = EINVAL;
		return (-1);
	}

	ip = (EInterval_t *)malloc(sizeof (EInterval_t));
	if (ip == NULL)
		return (-1);
	ip->num_tasks = tasks;
	ip->interval = interval;
	ip->next = NULL;
	ip->has_thread = 0;

	/* allocate and load table */
	ip->task_list = (ETask_t *)malloc(ip->num_tasks * sizeof (ETask_t));
	if (ip->task_list == NULL)
		return (-1);
	for (i = 0; i < ip->num_tasks; ++i) {
		tp = &ip->task_list[i];

		(void) fgets(buf, BUFSZ, fp);
		found = sscanf(buf, "%31s %1023s %63s",
		    name, library, tp->routine);
		if (found != 3) {
			errno = EINVAL;
			return (-1);
		}

		status = load_policy(library, tp);
		if (status == -1)
			return (-1);
		found = fscanf(fp, "%d", &tp->num_objects);
		if (found != 1) {
			if (debug_flag)
				syslog(LOG_ERR, "No list of objects for task");
			errno = EINVAL;
			return (-1);
		}
		tp->obj_list =
		    (EName_t *)malloc(tp->num_objects * sizeof (EName_t));
		if (tp->obj_list == NULL)
			return (-1);

		for (j = 0; j < tp->num_objects; ++j) {
			found = fscanf(fp, "%31s", (char *)(tp->obj_list + j));
			if (found != 1) {
				if (debug_flag)
					syslog(LOG_ERR,
					"Wrong number of objects for task");
				errno = EINVAL;
				return (-1);
			}
		}
		(void) fgets(buf, BUFSZ, fp);  /* reads newline on data line */
		(void) fgets(buf, BUFSZ, fp);
		if (strncmp(buf, "TASK_END", 8) != 0) {
			if (debug_flag)
				syslog(LOG_ERR, "Expected TASK_END, task %s",
				    tp->routine);
			errno = EINVAL;
			return (-1);
		}
	}

	(void) fgets(buf, BUFSZ, fp);
	if (strncmp(buf, "INTERVAL_END", 12) != 0) {
		if (debug_flag)
			syslog(LOG_ERR, "Expected INTERVAL_END");
		errno = EINVAL;
		return (-1);
	}

	*ipp = ip;
	return (0);
}

void
fini_daemon(void)
{
	EInterval_t *ip;

	/* shut down the threads running the policies */
	for (ip = first_interval; ip != NULL; ip = ip->next) {
		if (ip->has_thread) {
			/*
			 * there is a thread for this interval; tell it to stop
			 * by clearing the interval
			 */
			ip->interval = 0;
		}
	}
	for (ip = first_interval; ip != NULL; ip = ip->next) {
		if (ip->has_thread) {
			(void) pthread_join(ip->thread, NULL);
		}
	}
	/* shut down the timer thread */
	while (timer_state != READY)
		(void) sched_yield();
	(void) pthread_mutex_lock(&timer_mutex);
	timer_state = TIMER_SHUTDOWN;
	(void) pthread_cond_signal(&timer_cond);
	(void) pthread_mutex_unlock(&timer_mutex);
	(void) pthread_join(timer_thread_id, NULL);
	(void) pthread_mutex_destroy(&env_lock_mutex);
	(void) pthread_mutex_destroy(&timer_mutex);
	(void) pthread_cond_destroy(&timer_cond);
	(void) sem_destroy(&timer_sem);
}

void
init_daemon(void)
{
	int32_t intervals = 0;
	int32_t threads = 0;
	int32_t status;
	FILE *fp;
	char filename[PATH_MAX];
	char platform[64];
	EInterval_t *ip, *prev;

	if (sysinfo(SI_PLATFORM, platform, sizeof (platform)) == -1) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}

	(void) snprintf(filename, sizeof (filename),
	    "/usr/platform/%s/lib/platsvcd.conf", platform);
	if ((fp = fopen(filename, "r")) == NULL) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}

	status = get_timeout(fp, &app_timeout);
	if (status != 0) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}

	status = sem_init(&timer_sem, 0, 1);
	if (status == -1) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}

	(void) strlcpy(env_lock_state, PSVC_LOCK_ENABLED, LOCK_STRING_MAX);
	(void) pthread_mutex_init(&env_lock_mutex, NULL);
	(void) pthread_mutex_init(&timer_mutex, NULL);
	(void) pthread_cond_init(&timer_cond, NULL);

	timer_state = NOT_READY;
	status = pthread_create(&timer_thread_id, NULL,
	    (void *(*)())timer_thread, 0);
	if (status != 0) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}

	/* get timer thread running */
	while (timer_state != READY)
		(void) sched_yield();

	for (;;) {
		status = load_interval(fp, &ip);
		if (status != 0)
			break;

#ifdef	lint
		prev = NULL;
#endif
		if (first_interval == 0)
			first_interval = ip;
		else
			prev->next = ip;
		prev = ip;

		++intervals;
		if (ip->interval == 0) {
			run_policies(ip);
		} else {
			thread_setup(ip);
			++threads;
		}
	}
	if (intervals == 0) {
		if (debug_flag)
			syslog(LOG_ERR, "ERROR: No policies started");
		return;
	}

	if (status == -1) {
		if (debug_flag)
			syslog(LOG_ERR, "%s", strerror(errno));
		return;
	}
}


static int32_t count_records(FILE *fp, char *end, uint32_t *countp)
{
	long first_record;
	char *ret;
	char buf[BUFSZ];
	uint32_t count = 0;

	first_record = ftell(fp);

	while ((ret = fgets(buf, BUFSZ, fp)) != NULL) {
		if (strncmp(end, buf, strlen(end)) == 0)
			break;
		++count;
	}

	if (ret == NULL) {
		errno = EINVAL;
		return (-1);
	}

	(void) fseek(fp, first_record, SEEK_SET);
	*countp = count;
	return (0);
}

/*
 * Find start of a section within the config file,
 * Returns number of records in the section.
 * FILE *fd is set to first data record within section.
 */
static int32_t
find_file_section(FILE *fd, char *start)
{
	char *ret;
	char buf[BUFSZ];
	char name[32];
	int found;

	(void) fseek(fd, 0, SEEK_SET);
	while ((ret = fgets(buf, BUFSZ, fd)) != NULL) {
		if (strncmp(start, buf, strlen(start)) == 0)
			break;
	}

	if (ret == NULL) {
		errno = EINVAL;
		return (-1);
	}

	found = sscanf(buf, "%31s", name);
	if (found != 1) {
		errno = EINVAL;
		return (-1);
	} else {
		return (0);
	}

}

static int32_t name_compare_qsort(picl_psvc_t *s1, picl_psvc_t *s2)
{
	return (strcmp(s1->name, s2->name));
}

static int32_t name_compare_bsearch(char *s1, picl_psvc_t *s2)
{
	return (strcmp(s1, s2->name));
}

/*
 * Create a property and add it to the specified node.
 * PICL will take a segmentation violation if a volatile property
 * has a non-zero size.
 */
static int32_t node_property(picl_nodehdl_t node,
	int (*read)(ptree_rarg_t *, void *),
	int (*write)(ptree_warg_t *, const void *), picl_prop_type_t type,
	unsigned int size, unsigned int accessmode, char *name, void *value)
{
	ptree_propinfo_t propinfo;
	picl_prophdl_t prophdl;
	int err;

	propinfo.version = PSVC_PLUGIN_VERSION;
	if (accessmode & PICL_VOLATILE) {
		propinfo.read = read;
		propinfo.write = write;
	} else {
		propinfo.read = NULL;
		propinfo.write = NULL;
	}
	propinfo.piclinfo.type = type;
	propinfo.piclinfo.accessmode = accessmode;
	propinfo.piclinfo.size = size;
	(void) strcpy(propinfo.piclinfo.name, name);

	err = ptree_create_prop(&propinfo, value, &prophdl);
	if (err != 0) {
		return (err);
	}

	err = ptree_add_prop(node, prophdl);
	if (err != 0)
		return (err);

	return (0);
}

static void init_err(const char *fmt, char *arg1, char *arg2)
{
	char msg[256];

	(void) snprintf(msg, sizeof (msg), fmt, arg1, arg2);
	syslog(LOG_ERR, "%s", msg);
}

static int
projected_lookup(picl_prophdl_t proph, struct proj_prop **dstp)
{
	int i;

	for (i = 0; i < proj_prop_count; ++i) {
		if (prop_list[i].handle == proph) {
			*dstp = &prop_list[i];
			return (PICL_SUCCESS);
		}
	}

	return (PICL_INVALIDHANDLE);
}

int
projected_read(ptree_rarg_t *rarg, void *buf)
{
	ptree_propinfo_t propinfo;
	struct proj_prop *dstinfo;
	int err;

	err = projected_lookup(rarg->proph, &dstinfo);
	if (err != 0) {
		return (PICL_FAILURE);
	}


	err = ptree_get_propinfo(rarg->proph, &propinfo);
	if (err != 0)
		return (err);
	err = ptree_get_propval_by_name(dstinfo->dst_node,
	    dstinfo->name, buf, propinfo.piclinfo.size);
	if (err != 0)
		return (err);
	return (PICL_SUCCESS);
}

int
projected_write(ptree_warg_t *warg, const void *buf)
{
	ptree_propinfo_t propinfo;
	struct proj_prop *dstinfo;
	int err;

	err = projected_lookup(warg->proph, &dstinfo);
	if (err != 0) {
		return (PICL_FAILURE);
	}

	err = ptree_get_propinfo(warg->proph, &propinfo);
	if (err != 0)
		return (err);
	err = ptree_update_propval_by_name(dstinfo->dst_node,
	    dstinfo->name, buf, propinfo.piclinfo.size);
	if (err != 0)
		return (err);
	return (PICL_SUCCESS);
}

int
psvc_read_volatile(ptree_rarg_t *rarg, void *buf)
{
	ptree_propinfo_t propinfo;
	char name[32], class[32];
	int err, i;
	int32_t attr_num = -1;
	int32_t use_attr_num = 0;

	err = ptree_get_propval_by_name(rarg->nodeh, "name", name,
	    sizeof (name));
	if (err != 0) {
		return (err);
	}

	err = ptree_get_propval_by_name(rarg->nodeh, "_class", class,
	    sizeof (class));
	if (err != 0) {
		return (err);
	}

	err = ptree_get_propinfo(rarg->proph, &propinfo);
	if (err != 0) {
		return (err);
	}

	for (i = 0; i < PICL_PROP_TRANS_COUNT; i++) {
		if ((strcmp(class, picl_prop_trans[i].picl_class) == 0) &&
		    (strcmp(propinfo.piclinfo.name,
		    picl_prop_trans[i].picl_prop) == 0)) {
			attr_num = i;
			break;
		}
	}

	if (attr_num == -1)
		for (i = 0; i < ATTR_STR_TAB_SIZE; i++) {
			if (strcmp(propinfo.piclinfo.name,
			    attr_str_tab[i]) == 0) {
				attr_num = i;
				use_attr_num = 1;
				break;
			}
		}

	if (use_attr_num)
		err = psvc_get_attr(hdlp, name, attr_num, buf);
	else
		err = psvc_get_attr(hdlp, name,
		    picl_prop_trans[attr_num].psvc_prop,
		    buf);

	if (err != 0) {
		return (PICL_FAILURE);
	}
	return (PICL_SUCCESS);
}

int
psvc_write_volatile(ptree_warg_t *warg, const void *buf)
{
	ptree_propinfo_t propinfo;
	char name[32], class[32];
	int err, i;
	int32_t attr_num = -1;
	int32_t use_attr_num = 0;

	if (warg->cred.dc_euid != 0)
		return (PICL_PERMDENIED);

	err = ptree_get_propval_by_name(warg->nodeh, "name", name,
	    sizeof (name));
	if (err != 0) {
		return (err);
	}

	err = ptree_get_propval_by_name(warg->nodeh, "_class", class,
	    sizeof (class));
	if (err != 0) {
		return (err);
	}

	err = ptree_get_propinfo(warg->proph, &propinfo);
	if (err != 0) {
		return (err);
	}

	for (i = 0; i < PICL_PROP_TRANS_COUNT; i++) {
		if ((strcmp(class, picl_prop_trans[i].picl_class) == 0) &&
		    (strcmp(propinfo.piclinfo.name,
		    picl_prop_trans[i].picl_prop) == 0)) {
			attr_num = i;
			break;
		}
	}

	if (attr_num == -1)
		for (i = 0; i < ATTR_STR_TAB_SIZE; i++) {
			if (strcmp(propinfo.piclinfo.name,
			    attr_str_tab[i]) == 0) {
			attr_num = i;
			use_attr_num = 1;
			break;
			}
		}

	if (use_attr_num)
		err = psvc_set_attr(hdlp, name, attr_num, (void *)buf);
	else
		err = psvc_set_attr(hdlp, name,
		    picl_prop_trans[attr_num].psvc_prop,
		    (void *)buf);

	if (err != 0) {
		return (PICL_FAILURE);
	}

	return (PICL_SUCCESS);
}

void create_reference_properties(struct assoc_pair *assoc_tbl, int32_t count,
	char *assoc_name)
{
	picl_psvc_t *aobjp, *dobjp;
	picl_prophdl_t tbl_hdl;
	picl_nodehdl_t *dep_list;
	ptree_propinfo_t propinfo;
	char *funcname = "create_reference_properties"