xref: /titanic_52/usr/src/cmd/rcm_daemon/common/rcm_script.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * rcm scripting module:
 *
 * This module implements rcm scripting interfaces.
 * It translates rcm module based interfaces to rcm script based
 * interfaces.
 *
 * Entry points:
 *
 *   int script_main_init()
 *	Initialize the rcm scripting framework.
 *	Called during the rcm daemon initialization
 *
 *   int script_main_fini()
 *	Called at the time of the rcm daemon exit.
 *
 *   struct rcm_mod_ops *script_init(module_t *module)
 *	Initialize the given script.
 *	module->name contains the name of the script.
 *	Called at the time of loading scripts.
 *	Semantics are similar to module init.
 *
 *   char *script_info(module_t *module)
 *	Called when the rcm daemon wishes to get the script information.
 *	module->name contains the name of the script.
 *	Semantics are similar to module info.
 *
 *   int script_fini(module_t *module)
 *	Called before removing the script.
 *	module->name contains the name of the script.
 *	Semantics are similar to module fini.
 *
 * In addition to the above entry points rcm_mod_ops structure contains
 * the other entry points. A pointer to this structure is returned when
 * script_init() is called.
 */

#include "rcm_impl.h"
#include "rcm_script_impl.h"
#include <sys/resource.h>
#include <procfs.h>
#include <sys/proc.h>
#include <ctype.h>

/*
 * All rcm scripting commands are enumerated here.
 * NOTE: command positions in script_cmd_id_t and script_cmd_name must match.
 */
typedef enum {
	C_SCRIPTINFO,
	C_RESOURCEINFO,
	C_REGISTER,
	C_QUERYREMOVE,
	C_PREREMOVE,
	C_POSTREMOVE,
	C_UNDOREMOVE,
	C_QUERYCAPACITY,
	C_PRECAPACITY,
	C_POSTCAPACITY,
	C_QUERYSUSPEND,
	C_PRESUSPEND,
	C_POSTRESUME,
	C_CANCELSUSPEND
} script_cmd_id_t;

/* NOTE: command positions in script_cmd_id_t and script_cmd_name must match */
static char *script_cmd_name[] = {
	"scriptinfo",
	"resourceinfo",
	"register",
	"queryremove",
	"preremove",
	"postremove",
	"undoremove",
	"querycapacity",
	"precapacity",
	"postcapacity",
	"querysuspend",
	"presuspend",
	"postresume",
	"cancelsuspend",
	NULL
};

/*
 * All rcm scripting data items are enumerated here.
 * NOTE: data item positions in script_data_item_id_t and
 * script_data_item_name must match.
 */
typedef	enum {
	D_SCRIPT_VERSION,
	D_SCRIPT_FUNC_INFO,
	D_CMD_TIMEOUT,
	D_RESOURCE_NAME,
	D_RESOURCE_USAGE_INFO,
	D_FAILURE_REASON,
	D_LOG_ERR,
	D_LOG_WARN,
	D_LOG_INFO,
	D_LOG_DEBUG
} script_data_item_id_t;

/*
 * NOTE: data item positions in script_data_item_id_t and
 * script_data_item_name must match.
 */
static const char *script_data_item_name[] = {
	"rcm_script_version",
	"rcm_script_func_info",
	"rcm_cmd_timeout",
	"rcm_resource_name",
	"rcm_resource_usage_info",
	"rcm_failure_reason",
	"rcm_log_err",
	"rcm_log_warn",
	"rcm_log_info",
	"rcm_log_debug",
	NULL
};

/*
 * Maximum number of rcm scripts that can run in parallel.
 * RCM daemon has no limit on the number of scripts supported. But
 * at most it runs script_max_parallelism number of scripts in parallel.
 * For each running script rcm daemon consumes two file descriptors
 * in order to communicate with the script via pipes.
 * So maximum number of file descriptor entries consumed by rcm daemon
 * on behalf of rcm scripts is "script_max_parallelism * 2"
 */
static const int script_max_parallelism = 64;

/*
 * semaphore to limit the number of rcm script processes running in
 * parallel to script_max_parallelism.
 */
static sema_t script_process_sema;

/* mutex to protect the any global data */
static mutex_t script_lock;

/* contains head to a queue of script_info structures */
static rcm_queue_t script_info_q;

/*
 * This mmapped state file is used to store the process id and
 * rcm script name of all currently running rcm scripts.
 */
static const char *script_ps_state_file = "/var/run/rcm_script_state";
static state_file_descr_t script_ps_statefd;

static char *script_env_noforce = "RCM_ENV_FORCE=FALSE";
static char *script_env_force = "RCM_ENV_FORCE=TRUE";
static char *script_env_interval = "RCM_ENV_INTERVAL=%ld";

#define	RSCR_TRACE		RCM_TRACE1

/* rcm script base environment */
static char *script_env[MAX_ENV_PARAMS];

struct rlimit file_limit;

/* function prototypes */
static void build_env(void);
static void copy_env(char *[], char *[]);
static void open_state_file(const char *, state_file_descr_t *, size_t, int,
	uint32_t);
static void truncate_state_file(state_file_descr_t *);
static void close_state_file(const char *, state_file_descr_t *);
static void grow_state_file(state_file_descr_t *);
static void *get_state_element(state_file_descr_t *, int, int *);
static void *allocate_state_element(state_file_descr_t *, int *);
static void free_state_element(void *);
static void script_ps_state_file_kill_pids(void);
static void script_ps_state_file_add_entry(pid_t, char *);
static void script_ps_state_file_remove_entry(pid_t);
static int dname_to_id(char *);
static void script_process_sema_wait(void);
static int run_script(script_info_t *, char *[], char *[], char **);
static int get_line(int fd, char *, char *, int, size_t *, time_t, int *);
static void script_exited(script_info_t *);
static int kill_pid(pid_t);
static void kill_script(script_info_t *);
static char *flags_to_name(int, char *, int);
static void fill_argv(script_info_t *, char *[], char *);
static void *read_stderr(script_info_t *);
static int process_dataitem(script_info_t *, int, char *, char **);
static int do_cmd(script_info_t *, char *[], char *[], char **);
static int do_script_info(script_info_t *);
static int do_dr(script_info_t *, char *[], char *[], char **);
static int script_get_info(rcm_handle_t *, char *, pid_t, uint_t, char **,
	char **, nvlist_t *, rcm_info_t **);
static void add_for_unregister(script_info_t *);
static void remove_from_unregister(script_info_t *, char *);
static void complete_unregister(script_info_t *);
static int script_register_interest(rcm_handle_t *);
static void add_drreq(script_info_t *, char *);
static void remove_drreq(script_info_t *, char *);
static void remove_drreq_all(script_info_t *);
static int script_request_offline(rcm_handle_t *, char *, pid_t, uint_t,
	char **, rcm_info_t **);
static int script_notify_online(rcm_handle_t *, char *, pid_t, uint_t,
	char **, rcm_info_t **);
static int script_notify_remove(rcm_handle_t *, char *, pid_t, uint_t,
	char **, rcm_info_t **);
static int script_request_suspend(rcm_handle_t *, char *, pid_t, timespec_t *,
	uint_t, char **, rcm_info_t **);
static int script_notify_resume(rcm_handle_t *, char *, pid_t, uint_t,
	char **, rcm_info_t **);
static capacity_descr_t *get_capacity_descr(char *);
static int build_env_for_capacity(script_info_t *, char *, uint_t, nvlist_t *,
	char *[], int *, char **);
static int script_request_capacity_change(rcm_handle_t *, char *, pid_t,
	uint_t, nvlist_t *, char **, rcm_info_t **);
static int script_notify_capacity_change(rcm_handle_t *, char *, pid_t,
	uint_t, nvlist_t *, char **, rcm_info_t **);
static void log_msg(script_info_t *, int, char *);
static char *dup_err(int, char *, ...);
static void rcmscript_snprintf(char **, int *, char **, char *, ...);
static char *rcmscript_strdup(char *);
static void *rcmscript_malloc(size_t);
static void *rcmscript_calloc(size_t, size_t);


static struct rcm_mod_ops script_ops =
{
	RCM_MOD_OPS_VERSION,
	script_register_interest, /* register */
	script_register_interest, /* unregister */
	script_get_info,
	script_request_suspend,
	script_notify_resume,
	script_request_offline,
	script_notify_online,
	script_notify_remove,
	script_request_capacity_change,
	script_notify_capacity_change,
	NULL
};

/*
 * Messages fall into two categories:
 *   framework messages (MF_..)
 *   errors directly attributable to scripts (MS_..)
 */
#define	MF_MEMORY_ALLOCATION_ERR \
	gettext("rcm: failed to allocate memory: %1$s\n")
#define	MF_STATE_FILE_ERR \
	gettext("rcm: state file error: %1$s: %2$s\n")
#define	MF_FUNC_CALL_ERR \
	gettext("rcm: %1$s: %2$s\n")
#define	MF_NV_ERR \
	gettext("rcm: required name-value parameters missing (%1$s)\n")
#define	MF_UNKNOWN_RSRC_ERR \
	gettext("rcm: unknown resource name %1$s (%2$s)\n")
#define	MS_REGISTER_RSRC_ERR \
	gettext("rcm script %1$s: failed to register %2$s\n")
#define	MS_REGISTER_ERR \
	gettext("rcm script %1$s: register: %2$s\n")
#define	MS_SCRIPTINFO_ERR \
	gettext("rcm script %1$s: scriptinfo: %2$s\n")
#define	MS_PROTOCOL_ERR \
	gettext("rcm script %1$s: scripting protocol error\n")
#define	MS_TIMEOUT_ERR \
	gettext("rcm script %1$s: timeout error\n")
#define	MS_UNSUPPORTED_VER \
	gettext("rcm script %1$s: unsupported version %2$d\n")
#define	MS_SCRIPT_ERR \
	gettext("rcm script %1$s: error: %2$s\n")
#define	MS_UNKNOWN_ERR \
	gettext("rcm script %1$s: unknown error\n")
#define	MS_LOG_MSG \
	gettext("rcm script %1$s: %2$s\n")


/*
 * Initialize rcm scripting framework.
 * Called during initialization of rcm daemon.
 */
int
script_main_init(void)
{
#define	PS_STATE_FILE_CHUNK_SIZE	32

	/* set base script environment */
	build_env();

	rcm_init_queue(&script_info_q);

	/*
	 * Initialize the semaphore to limit the number of rcm script
	 * process running in parallel to script_max_parallelism.
	 */
	(void) sema_init(&script_process_sema, script_max_parallelism,
			USYNC_THREAD, NULL);

	(void) mutex_init(&script_lock, USYNC_THREAD, NULL);

	/* save original file limit */
	(void) getrlimit(RLIMIT_NOFILE, &file_limit);

	open_state_file(script_ps_state_file, &script_ps_statefd,
		sizeof (ps_state_element_t),
		PS_STATE_FILE_CHUNK_SIZE,
		PS_STATE_FILE_VER);

	/*
	 * If any pids exist in the ps state file since the last incarnation of
	 * the rcm daemon, kill the pids.
	 * On a normal daemon exit no pids should exist in the ps state file.
	 * But on an abnormal daemon exit pids may exist in the ps state file.
	 */
	if (script_ps_statefd.state_file) {
		script_ps_state_file_kill_pids();
		truncate_state_file(&script_ps_statefd);
	}

	return (0);
}

/*
 * Do any cleanup.
 * Called at the time of normal rcm daemon exit.
 */
int
script_main_fini(void)
{
	script_ps_state_file_kill_pids();
	close_state_file(script_ps_state_file, &script_ps_statefd);
	return (0);
}

/*
 * Initialize the given rcm script.
 * module->name contains the name of the rcm script.
 */
struct rcm_mod_ops *
script_init(module_t *module)
{
	script_info_t *rsi;
	size_t len;
	char *script_path;

	rcm_log_message(RSCR_TRACE, "script_init: script name = %s\n",
						module->name);

	module->rsi = NULL;

	if ((script_path = rcm_get_script_dir(module->name)) == NULL)
		return (NULL);

	len = strlen(script_path) + strlen(module->name) + 2;

	/* calloc also zeros the contents */
	rsi = (script_info_t *)rcmscript_calloc(1, sizeof (script_info_t));
	rsi->script_full_name = (char *)rcmscript_calloc(1, len);

	rsi->module = module;
	rcm_init_queue(&rsi->drreq_q);

	(void) mutex_init(&rsi->channel_lock, USYNC_THREAD, NULL);

	(void) snprintf(rsi->script_full_name, len, "%s%s", script_path,
			module->name);
	rsi->script_name = strrchr(rsi->script_full_name, '/') + 1;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->cmd_timeout = -1; /* don't time scriptinfo command */
	if (do_script_info(rsi) == RCM_SUCCESS) {
		/*
		 * if the script hasn't specified a timeout value set it to
		 * default
		 */
		if (rsi->cmd_timeout == -1)
			rsi->cmd_timeout = SCRIPT_CMD_TIMEOUT;
		(void) mutex_unlock(&rsi->channel_lock);

		/* put rsi on script_info_q */
		(void) mutex_lock(&script_lock);
		rcm_enqueue_tail(&script_info_q, &rsi->queue);
		(void) mutex_unlock(&script_lock);

		module->rsi = rsi;
		return (&script_ops);
	}

	(void) mutex_unlock(&rsi->channel_lock);

	free(rsi->script_full_name);
	free(rsi);
	return (NULL);
}

/*
 * Returns a string describing the script's functionality.
 * module->name contains the name of the rcm script for which information
 * is requested.
 */
char *
script_info(module_t *module)
{
	script_info_t *rsi = module->rsi;

	rcm_log_message(RSCR_TRACE, "script_info: script name = %s\n",
						rsi->script_name);
	return (rsi->func_info_buf);
}

/*
 * Called before unloading the script.
 * module->name contains the name of the rcm script which is being unloaded.
 * Do any cleanup.
 */
int
script_fini(module_t *module)
{
	script_info_t *rsi = module->rsi;

	rcm_log_message(RSCR_TRACE, "script_fini: script name = %s\n",
						rsi->script_name);

	/* remove rsi from script_info_q */
	(void) mutex_lock(&script_lock);
	rcm_dequeue(&rsi->queue);
	(void) mutex_unlock(&script_lock);

	remove_drreq_all(rsi);

	if (rsi->func_info_buf)
		free(rsi->func_info_buf);

	free(rsi->script_full_name);
	free(rsi);

	module->rsi = NULL;

	return (RCM_SUCCESS);
}

/* build base environment for scripts */
static void
build_env(void)
{
	const char *env_list[] = { "LANG", "LC_COLLATE", "LC_CTYPE",
		"LC_MESSAGES", "LC_MONETARY", "LC_NUMERIC", "LC_TIME",
		"LC_ALL", "TZ", NULL };
	char *x;
	int len;
	int i, j = 0;
	int d;
	extern int debug_level;

	script_env[j++] = rcmscript_strdup("PATH=/usr/sbin:/usr/bin");

	for (i = 0; env_list[i] != NULL; i++) {
		x = getenv(env_list[i]);
		if (x) {
			len = strlen(env_list[i]) + strlen(x) + 2;
			script_env[j] = (char *)rcmscript_malloc(len);

			(void) snprintf(script_env[j++], len, "%s=%s",
				env_list[i], x);
		}
	}

	len = strlen("RCM_ENV_DEBUG_LEVEL") + 3;
	script_env[j] = (char *)rcmscript_malloc(len);

	if (debug_level < 0)
		d = 0;
	else if (debug_level > 9)
		d = 9;
	else
		d = debug_level;

	(void) snprintf(script_env[j++], len, "RCM_ENV_DEBUG_LEVEL=%d", d);

	script_env[j] = NULL;
}

static void
copy_env(char *src[], char *dst[])
{
	int i;

	for (i = 0; src[i] != NULL; i++)
		dst[i] = src[i];

	dst[i] = NULL;
}

/*
 * Open (or create if the file does not exist) the given state file
 * and mmap it.
 */
static void
open_state_file(const char *filename,
	state_file_descr_t *statefd,
	size_t element_size,
	int chunk_size,
	uint32_t version)
{
	struct stat stats;
	int error_num;

	if ((statefd->fd = open(filename, O_CREAT|O_RDWR, 0600)) ==
			-1) {
		error_num = errno;
		rcm_log_message(RCM_ERROR, MF_STATE_FILE_ERR,
			"open", strerror(error_num));
		rcmd_exit(error_num);
		/*NOTREACHED*/
	}

	if (fstat(statefd->fd, &stats) != 0) {
		error_num = errno;
		rcm_log_message(RCM_ERROR, MF_STATE_FILE_ERR,
			"fstat", strerror(error_num));
		rcmd_exit(error_num);
		/*NOTREACHED*/
	}

	if (stats.st_size != 0) {
		/* LINTED */
		statefd->state_file = (state_file_t *)mmap(NULL,
			stats.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
			statefd->fd, 0);

		if (statefd->state_file == MAP_FAILED) {
			error_num = errno;
			rcm_log_message(RCM_ERROR, MF_STATE_FILE_ERR,
				"mmap", strerror(error_num));
			rcmd_exit(error_num);
			/*NOTREACHED*/
		}

		if (statefd->state_file->version != version) {
			(void) munmap((void *)statefd->state_file,
					stats.st_size);
			statefd->state_file = NULL;
			(void) ftruncate(statefd->fd, 0);
		}
	} else {
		statefd->state_file = NULL;
	}

	statefd->version = version;
	statefd->element_size = sizeof (state_element_t) +
				RSCR_ROUNDUP(element_size, 8);
	statefd->chunk_size = chunk_size;
	statefd->index = 0;
}

static void
truncate_state_file(state_file_descr_t *statefd)
{
	size_t size;

	if (statefd->state_file) {
		size = sizeof (state_file_t) + statefd->element_size *
			statefd->state_file->max_elements;

		(void) munmap((void *)statefd->state_file, size);
		statefd->state_file = NULL;
	}
	(void) ftruncate(statefd->fd, 0);
}

static void
close_state_file(const char *filename, state_file_descr_t *statefd)
{
	truncate_state_file(statefd);
	(void) close(statefd->fd);
	(void) unlink(filename);
}

/*
 * Grow the state file by the chunk size specified in statefd
 * and mmap it.
 */
static void
grow_state_file(state_file_descr_t *statefd)
{
	size_t size;
	int max_elements;
	int error_num;

	max_elements = statefd->chunk_size;
	if (statefd->state_file)
		max_elements += statefd->state_file->max_elements;

	size = sizeof (state_file_t) +
		statefd->element_size * max_elements;

	if (ftruncate(statefd->fd, size) != 0) {
		error_num = errno;
		rcm_log_message(RCM_ERROR, MF_STATE_FILE_ERR,
			"ftruncate", strerror(error_num));
		rcmd_exit(error_num);
		/*NOTREACHED*/
	}

	/* LINTED */
	statefd->state_file = (state_file_t *)mmap(NULL, size,
		PROT_READ|PROT_WRITE, MAP_SHARED, statefd->fd, 0);

	if (statefd->state_file == MAP_FAILED) {
		error_num = errno;
		rcm_log_message(RCM_ERROR, MF_STATE_FILE_ERR,
			"mmap", strerror(error_num));
		rcmd_exit(error_num);
		/*NOTREACHED*/
	}

	statefd->index = statefd->state_file->max_elements;
	statefd->state_file->max_elements = max_elements;
	statefd->state_file->version = statefd->version;
}

/*
 * Given index into state element array, get the pointer to the actual
 * state element.
 * If flag is non-null set *flag to
 *	TRUE if the state element is currently is use.
 *	FALSE if the state element is free.
 */
static void *
get_state_element(state_file_descr_t *statefd, int index, int *flag)
{
	char *ptr;

	if (statefd->state_file &&
	    (index < statefd->state_file->max_elements)) {

		ptr = (char *)(statefd->state_file);
		ptr += sizeof (state_file_t) +
			index * statefd->element_size;

		if (flag) {
			*flag = (((state_element_t *)((void *)ptr))->flags &
				STATE_ELEMENT_IN_USE) ? 1 : 0;
		}

		ptr += sizeof (state_element_t);
	} else
		ptr = NULL;

	return ((void *)ptr);
}

/*
 * Allocate a state element entry in the state file and return a pointer
 * to the allocated entry.
 * If index is non-null set *index to index into the state element array
 * of the allocated entry.
 */
static void *
allocate_state_element(state_file_descr_t *statefd, int *index)
{
	void *x;
	int i;
	int flag;

	if (statefd->state_file) {
		/* find an empty slot */
		for (i = 0; i < statefd->state_file->max_elements; i++) {
			x = get_state_element(statefd, statefd->index,
						&flag);
			assert(x != NULL);

			if (flag == 0)
				/* entry is free */
				break;

			statefd->index++;
			if (statefd->index >= statefd->state_file->max_elements)
				statefd->index = 0;
		}
	}

	if (statefd->state_file == NULL ||
		i == statefd->state_file->max_elements) {

		/* All entries are in use. Grow the list */
		grow_state_file(statefd);
		x = get_state_element(statefd, statefd->index, &flag);
		assert(flag == 0);
	}

	if (index != NULL)
		*index = statefd->index;

	statefd->index++;
	if (statefd->index >= statefd->state_file->max_elements)
		statefd->index = 0;

	((state_element_t *)x - 1)->flags |= STATE_ELEMENT_IN_USE;
	return (x);
}

static void
free_state_element(void *x)
{
	((state_element_t *)x - 1)->flags &= ~STATE_ELEMENT_IN_USE;
}

/*
 * Kill the pids contained in ps state file.
 */
static void
script_ps_state_file_kill_pids(void)
{
	ps_state_element_t *x;
	char procfile[80];
	psinfo_t psi;
	int fd, i, flag;

	/* LINTED */
	for (i = 0; 1; i++) {
		if ((x = (ps_state_element_t *)get_state_element(
					&script_ps_statefd, i, &flag)) == NULL)
			break;

		if (flag == 1) { /* the entry is in use */
			(void) snprintf(procfile, 80, "/proc/%ld/psinfo",
					(long)x->pid);
			if ((fd = open(procfile, O_RDONLY)) != -1 &&
				read(fd, &psi, sizeof (psi)) == sizeof (psi) &&
				strcmp(psi.pr_fname,
				x->script_name) == 0) {

				(void) close(fd);

				/*
				 * just a safety check to not to blow up
				 * system processes if the file is ever corrupt
				 */
				if (x->pid > 1) {
					rcm_log_message(RCM_DEBUG,
					"script_ps_state_file_kill_pids: "
					"killing script_name = %s pid = %ld\n",
					x->script_name, x->pid);

					/* kill the process group */
					(void) kill(-(x->pid), SIGKILL);
				}
			} else {
				if (fd != -1)
					(void) close(fd);
			}
			free_state_element((void *)x);
		}
	}
}

/*
 * Add a state element entry to ps state file.
 */
static void
script_ps_state_file_add_entry(pid_t pid, char *script_name)
{
	ps_state_element_t *x;

	(void) mutex_lock(&script_lock);

	x = (ps_state_element_t *)allocate_state_element(
		&script_ps_statefd, NULL);

	x->pid = pid;
	(void) strlcpy(x->script_name, script_name, MAXNAMELEN);

	(void) fsync(script_ps_statefd.fd);

	(void) mutex_unlock(&script_lock);
}

/*
 * Remove the state element entry corresponding to pid from the
 * ps state file.
 */
static void
script_ps_state_file_remove_entry(pid_t pid)
{
	ps_state_element_t *x;
	int flag, i;

	(void) mutex_lock(&script_lock);

	/* LINTED */
	for (i = 0; 1; i++) {
		if ((x = (ps_state_element_t *)get_state_element(
					&script_ps_statefd, i, &flag)) == NULL)
			break;

		/* if the state element entry is in use and pid matches */
		if (flag == 1 && x->pid == pid) {
			free_state_element((void *)x);
			break;
		}
	}

	(void) mutex_unlock(&script_lock);
}

/*
 * Get data item id given data item name
 */
static int
dname_to_id(char *dname)
{
	int i;

	for (i = 0; script_data_item_name[i] != NULL; i++) {
		if (strcmp(dname, script_data_item_name[i]) == 0)
			return (i);
	}

	return (-1);
}

/*
 * Called before running any script.
 * This routine waits until the number of script processes running in
 * parallel drops down below to script_max_parallelism.
 */
static void
script_process_sema_wait(void)
{
	int error_num;

	/* LINTED */
	while (1) {
		if (sema_wait(&script_process_sema) == 0)
			return;

		if (errno != EINTR && errno != EAGAIN) {
			error_num = errno;
			rcm_log_message(RCM_ERROR, MF_FUNC_CALL_ERR,
				"sema_wait", strerror(error_num));
			rcmd_exit(error_num);
			/*NOTREACHED*/
		}
	}

	/*NOTREACHED*/
}

/*
 * Fork and execute the script.
 */
static int
run_script(script_info_t *rsi, char *argv[], char *envp[], char **errmsg)
{
	int i, p1 = -1, p2 = -1;
	struct rlimit rlp;
	struct stat stats;

	rcm_log_message(RSCR_TRACE, "run_script: script name = %s\n",
					rsi->script_full_name);

	for (i = 0; argv[i] != NULL; i++)
		rcm_log_message(RSCR_TRACE, "run_script: argv[%d] = %s\n",
					i, argv[i]);

	*errmsg = NULL;

	/* check that the script exists */
	if (stat(rsi->script_full_name, &stats) != 0)
		goto error;

	/*
	 * If the syscall pipe fails because of reaching the max open file
	 * count per process then dynamically increase the limit on the max
	 * open file count.
	 *
	 * At present the rcm_daemon consumes file descriptor
	 * entries for the following files.
	 *   RCM_STATE_FILE   - /var/run/rcm_daemon_state
	 *   DAEMON_LOCK_FILE - /var/run/rcm_daemon_lock
	 *   RCM_SERVICE_DOOR - /var/run/rcm_daemon_door
	 *   proc files in the format "/proc/pid/as" for each pid
	 *	communicating with the rcm_daemon via doors
	 *   dlopen for each rcm module
	 *   When in daemon mode stdin, stdout and stderr are closed;
	 *	/dev/null opened and duped to stdout, and stderr
	 *   openlog
	 *   Some files which are opened briefly and closed such as
	 *	directory files.
	 *   Two file descriptors for each script in running state.
	 *	Note that the constant script_max_parallelism sets an
	 *	upper cap on how many rcm scripts can run in
	 *	parallel.
	 */
	if ((p1 = pipe(rsi->pipe1)) == -1 || (p2 = pipe(rsi->pipe2)) == -1) {
		if ((errno == EMFILE) &&
			(getrlimit(RLIMIT_NOFILE, &rlp) == 0)) {

			rlp.rlim_cur += 16;
			if (rlp.rlim_max < rlp.rlim_cur)
				rlp.rlim_max = rlp.rlim_cur;
			(void) setrlimit(RLIMIT_NOFILE, &rlp);

			if (p1 == -1) {
				if ((p1 = pipe(rsi->pipe1)) == -1)
					goto error;
			}
			if ((p2 = pipe(rsi->pipe2)) == -1)
				goto error;
		} else
			goto error;
	}

forkagain:
	if ((rsi->pid = fork1()) == (pid_t)-1) {
		if (errno == EINTR || errno == EAGAIN)
			goto forkagain;

		goto error;
	}

	if (rsi->pid == 0) {
		/* child process */

		(void) setsid();

		/* close stdin, stdout and stderr */
		(void) close(0);
		(void) close(1);
		(void) close(2);

		/* set stdin to /dev/null */
		(void) open("/dev/null", O_RDWR, 0);

		/* redirect stdout and stderr to pipe */
		(void) dup2(rsi->pipe1[CHILD_END_OF_PIPE], 1);
		(void) dup2(rsi->pipe2[CHILD_END_OF_PIPE], 2);

		/* close all other file descriptors */
		closefrom(3);

		/* restore original file limit */
		(void) setrlimit(RLIMIT_NOFILE, &file_limit);

		/* set current working dir */
		if (stats.st_uid == 0) {
			/* root */
			if (chdir("/var/run") == -1)
				_exit(127);
		} else {
			if (chdir("/tmp") == -1)
				_exit(127);
		}

		/*
		 * setuid sets real, effective and saved user ids to the
		 * given id.
		 * setgid sets real, effective and saved group ids to the
		 * given id.
		 */
		(void) setgid(stats.st_gid);
		(void) setuid(stats.st_uid);

		(void) execve(rsi->script_full_name, argv, envp);
		_exit(127);
		/*NOTREACHED*/
	}

	(void) close(rsi->pipe1[CHILD_END_OF_PIPE]);
	(void) close(rsi->pipe2[CHILD_END_OF_PIPE]);

	script_ps_state_file_add_entry(rsi->pid, rsi->script_name);

	return (0);

error:
	*errmsg = dup_err(RCM_ERROR, MS_SCRIPT_ERR,
			rsi->script_name, strerror(errno));

	if (p1 != -1) {
		(void) close(rsi->pipe1[PARENT_END_OF_PIPE]);
		(void) close(rsi->pipe1[CHILD_END_OF_PIPE]);
	}

	if (p2 != -1) {
		(void) close(rsi->pipe2[PARENT_END_OF_PIPE]);
		(void) close(rsi->pipe2[CHILD_END_OF_PIPE]);
	}

	return (-1);
}

/*
 * Reads one line of input (including the newline character) from the
 * given file descriptor "fd" to buf.
 * maxbuflen specifies the size of memory allocated for buf.
 * Timeoutval is the max timeout value in seconds for the script to supply
 * input. A timeoutval of 0 implies no timeout.
 *
 * Upon return *buflen contains the number of bytes read.
 *
 * Return values:
 *   0  success
 *   -1 an error occured
 *   -2 timeout occurred
 *   -3 script exited
 */
static int
get_line(int fd,
	char *fdname,
	char *buf,
	int maxbuflen,
	size_t *buflen,
	time_t timeoutval,
	int *error_num)
{
	char c = '\0';
	struct pollfd fds[1];
	int x;
	size_t len = 0;
	char *ptr;
	int timeit;
	time_t deadline;
	int rval = 0;

	if (timeoutval) {
		timeit = TRUE;
		deadline = time(NULL) + timeoutval;
		fds[0].fd = fd;
		fds[0].events = POLLIN;
	} else
		timeit = FALSE;

	ptr = buf;

	while (c != '\n' && len < (maxbuflen -1)) {
		if (timeit) {
pollagain:
			fds[0].revents = 0;
			timeoutval = deadline - time(NULL);
			if (timeoutval <= 0) {
				rval = -2;
				break;
			}
			x = poll(fds, 1, timeoutval*1000);
			if (x <= 0) {
				if (x == 0)
					/* poll timedout */
					rval = -2;
				else {
					if (errno == EINTR || errno == EAGAIN)
						goto pollagain;
					*error_num = errno;
					rval = -1;
				}
				break;
			}
		}
readagain:
		if ((x = read(fd, &c, 1)) != 1) {
			if (x == 0)
				/*
				 * Script exited. Or more specifically the
				 * script has closed its end of the pipe.
				 */
				rval = -3;
			else {
				if (errno == EINTR || errno == EAGAIN)
					goto readagain;
				*error_num = errno;
				rval = -1;
			}
			break;
		}

		*ptr++ = c;
		len++;
	}

	*ptr = '\0';
	*buflen = len;

	rcm_log_message(RSCR_TRACE,
		"get_line(%s): rval = %d buflen = %d line = %s\n",
		fdname, rval, *buflen, buf);
	return (rval);
}

static void
script_exited(script_info_t *rsi)
{
	if (rsi->flags & STDERR_THREAD_CREATED) {
		rcm_log_message(RSCR_TRACE,
		    "script_exited: doing thr_join (%s)\n", rsi->script_name);
		(void) thr_join(rsi->tid, NULL, NULL);
		rsi->flags &= ~STDERR_THREAD_CREATED;
	}

	(void) close(rsi->pipe1[PARENT_END_OF_PIPE]);
	(void) close(rsi->pipe2[PARENT_END_OF_PIPE]);
	rsi->pipe1[PARENT_END_OF_PIPE] = -1;
	rsi->pipe2[PARENT_END_OF_PIPE] = -1;

	script_ps_state_file_remove_entry(rsi->pid);
	rsi->pid = 0;
	(void) sema_post(&script_process_sema);
}

/*
 * Kill the specified process group
 */
static int
kill_pid(pid_t pid)
{
	time_t deadline, timeleft;
	int child_status;

	/* kill the entire process group */
	(void) kill(-(pid), SIGKILL);

	/* give some time for the script to be killed */
	deadline = time(NULL) + SCRIPT_KILL_TIMEOUT;
	do {
		if (waitpid(pid, &child_status, WNOHANG) == pid)
			return (0);

		/* wait for 100 ms */
		(void) poll(NULL, 0, 100);

		timeleft = deadline - time(NULL);
	} while (timeleft > 0);

	/* script process was not killed successfully */
	return (-1);
}

/*
 * Kill the specified script.
 */
static void
kill_script(script_info_t *rsi)
{
	if (rsi->pid > 1) {
		(void) kill_pid(rsi->pid);
		script_exited(rsi);
		remove_drreq_all(rsi);
	}
}

/*
 * Convert rcm flags parameter to a string.
 * Used for debug prints.
 */
static char *
flags_to_name(int flags, char *buf, int maxbuflen)
{
	(void) snprintf(buf, maxbuflen, "%s%s",
		(flags & RCM_QUERY) ? "RCM_QUERY " : "",
		(flags & RCM_FORCE) ? "RCM_FORCE" : "");

	return (buf);
}

static void
fill_argv(script_info_t *rsi, char *argv[], char *resource_name)
{
	argv[0] = rsi->script_full_name;
	argv[1] = script_cmd_name[rsi->cmd];
	if (resource_name) {
		argv[2] = resource_name;
		argv[3] = NULL;
	} else
		argv[2] = NULL;
}

/*
 * stderr thread:
 * Reads stderr and logs to syslog.
 * Runs as a separate thread.
 */
static void *
read_stderr(script_info_t *rsi)
{
	char buf[MAX_LINE_LEN];
	size_t buflen;
	int error_num;

	while ((get_line(rsi->pipe2[PARENT_END_OF_PIPE], "stderr",
		buf, MAX_LINE_LEN, &buflen, 0, &error_num)) == 0) {
		log_msg(rsi, RCM_ERROR, buf);
	}

	if (buflen)
		log_msg(rsi, RCM_ERROR, buf);

	return (NULL);
}

/* process return data items passed by scripts to the framework */
static int
process_dataitem(script_info_t *rsi, int token, char *value, char **errmsg)
{
	char *ptr;
	int status;

	*errmsg = NULL;

	if (*value == '\0')
		goto error;

	switch (token) {
	case D_SCRIPT_VERSION:
		if (rsi->cmd != C_SCRIPTINFO)
			goto error;

		/* check that value contains only digits */
		for (ptr = value; *ptr != '\0'; ptr++)
			if (isdigit((int)(*ptr)) == 0)
				break;

		if (*ptr == '\0')
			rsi->ver = atoi(value);
		else
			goto error;

		break;

	case D_SCRIPT_FUNC_INFO:
		if (rsi->cmd != C_SCRIPTINFO)
			goto error;

		rcmscript_snprintf(&rsi->func_info_buf,
			&rsi->func_info_buf_len,
			&rsi->func_info_buf_curptr,
			"%s", value);
		break;

	case D_CMD_TIMEOUT:
		if (rsi->cmd != C_SCRIPTINFO)
			goto error;

		/* check that value contains only digits */
		for (ptr = value; *ptr != '\0'; ptr++)
			if (isdigit((int)(*ptr)) == 0)
				break;

		if (*ptr == '\0')
			rsi->cmd_timeout = atoi(value);
		else
			goto error;
		break;

	case D_RESOURCE_NAME:
		if (rsi->cmd != C_REGISTER)
			goto error;

		if (get_capacity_descr(value) != NULL)
			status = rcm_register_capacity(rsi->hdl, value,
					0, NULL);
		else
			status = rcm_register_interest(rsi->hdl, value, 0,
					NULL);

		if (status == RCM_FAILURE && errno == EALREADY)
			status = RCM_SUCCESS;

		if (status != RCM_SUCCESS) {
			rcm_log_message(RCM_ERROR, MS_REGISTER_RSRC_ERR,
				rsi->script_name, value);
		}

		remove_from_unregister(rsi, value);
		break;

	case D_RESOURCE_USAGE_INFO:
		if (rsi->cmd != C_RESOURCEINFO)
			goto error;

		rcmscript_snprintf(&rsi->resource_usage_info_buf,
			&rsi->resource_usage_info_buf_len,
			&rsi->resource_usage_info_buf_curptr,
			"%s", value);
		break;

	case D_FAILURE_REASON:
		rcmscript_snprintf(&rsi->failure_reason_buf,
			&rsi->failure_reason_buf_len,
			&rsi->failure_reason_buf_curptr,
			"%s", value);
		break;

	default:
		goto error;
	}

	return (0);

error:
	*errmsg = dup_err(RCM_ERROR, MS_PROTOCOL_ERR, rsi->script_name);
	return (-1);
}

/* Send the given command to the script and process return data */
static int
do_cmd(script_info_t *rsi, char *argv[], char *envp[], char **errmsg)
{
	char buf[MAX_LINE_LEN];
	size_t buflen;
	int loglevel = -1, continuelog = 0;
	char *ptr, *dname, *value;
	time_t maxsecs;
	time_t deadline;
	int sigaborted = 0;
	int rval, child_status, token;
	int error_num;
	int cmd_timeout = rsi->cmd_timeout;

	*errmsg = NULL;

	script_process_sema_wait();

	if (run_script(rsi, argv, envp, errmsg) == -1) {
		(void) sema_post(&script_process_sema);
		goto error2;
	}

	(void) time(&rsi->lastrun);
	deadline = rsi->lastrun + cmd_timeout;

	if (thr_create(NULL, 0, (void *(*)(void *))read_stderr, rsi,
	    0, &rsi->tid) != 0) {
		*errmsg = dup_err(RCM_ERROR, MF_FUNC_CALL_ERR,
				"thr_create", strerror(errno));
		goto error1;
	}
	rsi->flags |= STDERR_THREAD_CREATED;

	/* LINTED */
	while (1) {
		if (cmd_timeout > 0) {
			maxsecs = deadline - time(NULL);
			if (maxsecs <= 0)
				goto timedout;
		} else
			maxsecs = 0;

		rval = get_line(rsi->pipe1[PARENT_END_OF_PIPE],
				"stdout", buf, MAX_LINE_LEN, &buflen,
				maxsecs, &error_num);

		if (buflen) {
			if (continuelog)
				log_msg(rsi, loglevel, buf);
			else {
				if ((ptr = strchr(buf, '=')) == NULL)
					goto error;

				*ptr = '\0';
				dname = buf;
				value = ptr + 1;
				if ((token = dname_to_id(dname)) == -1)
					goto error;

				switch (token) {
				case D_LOG_ERR:
					loglevel = RCM_ERROR;
					break;

				case D_LOG_WARN:
					loglevel = RCM_WARNING;
					break;

				case D_LOG_INFO:
					loglevel = RCM_INFO;
					break;

				case D_LOG_DEBUG:
					loglevel = RCM_DEBUG;
					break;

				default:
					loglevel = -1;
					break;
				}

				if (loglevel != -1) {
					log_msg(rsi, loglevel, value);
					if (buf[buflen - 1] == '\n')
						continuelog = 0;
					else
						continuelog = 1;
				} else {
					if (buf[buflen - 1] != '\n')
						goto error;

					buf[buflen - 1] = '\0';
					if (process_dataitem(rsi, token,
						value, errmsg) != 0)
						goto error1;
				}
			}
		}

		if (rval == -3) {
			/* script exited */
waitagain:
			if (waitpid(rsi->pid, &child_status, 0)
					!= rsi->pid) {
				if (errno == EINTR || errno == EAGAIN)
					goto waitagain;
				*errmsg = dup_err(RCM_ERROR, MS_SCRIPT_ERR,
					rsi->script_name, strerror(errno));
				goto error1;
			}

			if (WIFEXITED(child_status)) {
				script_exited(rsi);
				rsi->exit_status = WEXITSTATUS(child_status);
			} else {
				if (sigaborted)
					*errmsg = dup_err(RCM_ERROR,
					MS_TIMEOUT_ERR, rsi->script_name);
				else
					*errmsg = dup_err(RCM_ERROR,
					MS_UNKNOWN_ERR, rsi->script_name);

				/* kill any remaining processes in the pgrp */
				(void) kill(-(rsi->pid), SIGKILL);
				script_exited(rsi);
				goto error2;
			}

			break;
		}

		if (rval == -1) {
			*errmsg = dup_err(RCM_ERROR, MS_SCRIPT_ERR,
				rsi->script_name, strerror(errno));
			goto error1;
		}

		if (rval == -2) {
timedout:
			/* timeout occurred */
			if (sigaborted == 0) {
				(void) kill(rsi->pid, SIGABRT);
				sigaborted = 1;
				/* extend deadline */
				deadline += SCRIPT_ABORT_TIMEOUT;
			} else {
				*errmsg = dup_err(RCM_ERROR,
					MS_TIMEOUT_ERR, rsi->script_name);
				goto error1;
			}
		}
	}

	return (0);

error:
	*errmsg = dup_err(RCM_ERROR, MS_PROTOCOL_ERR, rsi->script_name);

error1:
	kill_script(rsi);

error2:
	return (-1);
}

static int
do_script_info(script_info_t *rsi)
{
	char *argv[MAX_ARGS];
	int status = RCM_FAILURE;
	int err = 0;
	char *errmsg = NULL;

	rcm_log_message(RSCR_TRACE, "do_script_info: script name = %s\n",
						rsi->script_name);

	rsi->cmd = C_SCRIPTINFO;
	rsi->func_info_buf = NULL;
	rsi->failure_reason_buf = NULL;
	fill_argv(rsi, argv, NULL);

	if (do_cmd(rsi, argv, script_env, &errmsg) == 0) {
		switch (rsi->exit_status) {
		case E_SUCCESS:
			if (rsi->func_info_buf != NULL &&
				rsi->failure_reason_buf == NULL) {

				if (rsi->ver >= SCRIPT_API_MIN_VER &&
					rsi->ver <= SCRIPT_API_MAX_VER)
					status = RCM_SUCCESS;
				else
					rcm_log_message(RCM_ERROR,
					MS_UNSUPPORTED_VER, rsi->script_name,
					rsi->ver);
			} else
				err = 1;
			break;

		case E_FAILURE:
			if (rsi->failure_reason_buf != NULL) {
				rcm_log_message(RCM_ERROR, MS_SCRIPTINFO_ERR,
					rsi->script_name,
					rsi->failure_reason_buf);
			} else
				err = 1;
			break;

		default:
			err = 1;
			break;
		}
		if (err)
			rcm_log_message(RCM_ERROR, MS_PROTOCOL_ERR,
				rsi->script_name);
	} else if (errmsg)
		(void) free(errmsg);

	if (status != RCM_SUCCESS && rsi->func_info_buf != NULL)
		free(rsi->func_info_buf);

	if (rsi->failure_reason_buf)
		free(rsi->failure_reason_buf);

	return (status);
}

static int
do_dr(script_info_t *rsi, char *argv[], char *envp[], char **info)
{
	int status = RCM_FAILURE;
	int err = 0;

	rsi->failure_reason_buf = NULL;

	if (do_cmd(rsi, argv, envp, info) == 0) {
		switch (rsi->exit_status) {
		case E_SUCCESS:
		case E_UNSUPPORTED_CMD:
			if (rsi->failure_reason_buf == NULL)
				status = RCM_SUCCESS;
			else
				err = 1;
			break;

		case E_FAILURE:
		case E_REFUSE:
			if (rsi->failure_reason_buf != NULL) {
				*info = rsi->failure_reason_buf;
				rsi->failure_reason_buf = NULL;
			} else
				err = 1;
			break;

		default:
			err = 1;
			break;
		}

		if (err)
			*info = dup_err(RCM_ERROR, MS_PROTOCOL_ERR,
				rsi->script_name);
	}

	if (rsi->failure_reason_buf)
		free(rsi->failure_reason_buf);

	return (status);
}

/*
 * get_info entry point
 */
/* ARGSUSED */
static int
script_get_info(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	char **info,
	char **error,
	nvlist_t *props,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	int status = RCM_FAILURE;
	int err = 0;

	rcm_log_message(RSCR_TRACE, "script_get_info: resource = %s\n",
				resource_name);

	*info = NULL;
	*error = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = C_RESOURCEINFO;
	rsi->resource_usage_info_buf = NULL;
	rsi->failure_reason_buf = NULL;
	fill_argv(rsi, argv, resource_name);

	if (do_cmd(rsi, argv, script_env, error) == 0) {
		switch (rsi->exit_status) {
		case E_SUCCESS:
			if (rsi->resource_usage_info_buf != NULL &&
				rsi->failure_reason_buf == NULL) {

				*info = rsi->resource_usage_info_buf;
				rsi->resource_usage_info_buf = NULL;
				status = RCM_SUCCESS;
			} else
				err = 1;
			break;

		case E_FAILURE:
			if (rsi->failure_reason_buf != NULL) {
				*error = rsi->failure_reason_buf;
				rsi->failure_reason_buf = NULL;
			} else
				err = 1;
			break;

		default:
			err = 1;
			break;
		}
		if (err)
			*error = dup_err(RCM_ERROR, MS_PROTOCOL_ERR,
				rsi->script_name);
	}

	if (rsi->resource_usage_info_buf)
		free(rsi->resource_usage_info_buf);

	if (rsi->failure_reason_buf)
		free(rsi->failure_reason_buf);

	(void) mutex_unlock(&rsi->channel_lock);

	return (status);
}

static void
add_for_unregister(script_info_t *rsi)
{
	module_t *module = rsi->module;
	client_t *client;
	rcm_queue_t *head;
	rcm_queue_t *q;

	(void) mutex_lock(&rcm_req_lock);

	head = &module->client_q;

	for (q = head->next; q != head; q = q->next) {
		client = RCM_STRUCT_BASE_ADDR(client_t, q, queue);
		client->prv_flags |= RCM_NEED_TO_UNREGISTER;
	}

	(void) mutex_unlock(&rcm_req_lock);
}

static void
remove_from_unregister(script_info_t *rsi, char *resource_name)
{
	module_t *module = rsi->module;
	client_t *client;
	rcm_queue_t *head;
	rcm_queue_t *q;

	(void) mutex_lock(&rcm_req_lock);

	head = &module->client_q;

	for (q = head->next; q != head; q = q->next) {
		client = RCM_STRUCT_BASE_ADDR(client_t, q, queue);
		if (strcmp(client->alias, resource_name) == 0) {
			client->prv_flags &= ~RCM_NEED_TO_UNREGISTER;
			break;
		}
	}

	(void) mutex_unlock(&rcm_req_lock);
}

static void
complete_unregister(script_info_t *rsi)
{
	module_t *module = rsi->module;
	client_t *client;
	rcm_queue_t *head;
	rcm_queue_t *q;

	(void) mutex_lock(&rcm_req_lock);

	head = &module->client_q;

	for (q = head->next; q != head; q = q->next) {
		client = RCM_STRUCT_BASE_ADDR(client_t, q, queue);
		if (client->prv_flags & RCM_NEED_TO_UNREGISTER) {
			client->prv_flags &= ~RCM_NEED_TO_UNREGISTER;
			client->state = RCM_STATE_REMOVE;
		}
	}

	(void) mutex_unlock(&rcm_req_lock);
}

/*
 * register_interest entry point
 */
static int
script_register_interest(rcm_handle_t *hdl)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	int status = RCM_FAILURE;
	int err = 0;
	char *errmsg = NULL;

	rcm_log_message(RSCR_TRACE,
		"script_register_interest: script name = %s\n",
		rsi->script_name);

	(void) mutex_lock(&rsi->channel_lock);

	if (rsi->drreq_q.next != &rsi->drreq_q) {
		/* if DR is already in progress no need to register again */
		(void) mutex_unlock(&rsi->channel_lock);
		return (RCM_SUCCESS);
	}

	rsi->hdl = hdl;
	rsi->cmd = C_REGISTER;
	rsi->failure_reason_buf = NULL;
	fill_argv(rsi, argv, NULL);

	add_for_unregister(rsi);

	if (do_cmd(rsi, argv, script_env, &errmsg) == 0) {
		switch (rsi->exit_status) {
		case E_SUCCESS:
			status = RCM_SUCCESS;
			break;

		case E_FAILURE:
			if (rsi->failure_reason_buf != NULL) {
				rcm_log_message(RCM_ERROR, MS_REGISTER_ERR,
					rsi->script_name,
					rsi->failure_reason_buf);
			} else
				err = 1;
			break;

		default:
			err = 1;
			break;
		}
		if (err)
			rcm_log_message(RCM_ERROR, MS_PROTOCOL_ERR,
				rsi->script_name);
	} else if (errmsg)
		(void) free(errmsg);

	complete_unregister(rsi);

	if (rsi->failure_reason_buf)
		free(rsi->failure_reason_buf);

	(void) mutex_unlock(&rsi->channel_lock);

	return (status);
}

/*
 * Add the specified resource name to the drreq_q.
 */
static void
add_drreq(script_info_t *rsi, char *resource_name)
{
	rcm_queue_t *head = &rsi->drreq_q;
	rcm_queue_t *q;
	drreq_t *drreq;

	/* check if the dr req is already in the list */
	for (q = head->next; q != head; q = q->next) {
		drreq = RCM_STRUCT_BASE_ADDR(drreq_t, q, queue);
		if (strcmp(drreq->resource_name, resource_name) == 0)
			/* dr req is already present in the queue */
			return;
	}

	drreq = (drreq_t *)rcmscript_calloc(1, sizeof (drreq_t));
	drreq->resource_name = rcmscript_strdup(resource_name);

	rcm_enqueue_tail(&rsi->drreq_q, &drreq->queue);
}

/*
 * Remove the dr req for the specified resource name from the drreq_q.
 */
static void
remove_drreq(script_info_t *rsi, char *resource_name)
{
	rcm_queue_t *head = &rsi->drreq_q;
	rcm_queue_t *q;
	drreq_t *drreq;

	/* search for dr req and remove from the list */
	for (q = head->next; q != head; q = q->next) {
		drreq = RCM_STRUCT_BASE_ADDR(drreq_t, q, queue);
		if (strcmp(drreq->resource_name, resource_name) == 0)
			break;
	}

	if (q != head) {
		/* found drreq on the queue */
		rcm_dequeue(&drreq->queue);
		free(drreq->resource_name);
		free(drreq);
	}
}

/*
 * Remove all dr req's.
 */
static void
remove_drreq_all(script_info_t *rsi)
{
	drreq_t *drreq;

	while (rsi->drreq_q.next != &rsi->drreq_q) {
		drreq = RCM_STRUCT_BASE_ADDR(drreq_t,
					rsi->drreq_q.next, queue);
		remove_drreq(rsi, drreq->resource_name);
	}
}

/*
 * request_offline entry point
 */
/* ARGSUSED */
static int
script_request_offline(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	char *envp[MAX_ENV_PARAMS];
	char flags_name[MAX_FLAGS_NAME_LEN];
	int status;
	int i;

	rcm_log_message(RSCR_TRACE,
		"script_request_offline: resource = %s flags = %s\n",
			resource_name,
			flags_to_name(flag, flags_name, MAX_FLAGS_NAME_LEN));

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = (flag & RCM_QUERY) ? C_QUERYREMOVE : C_PREREMOVE;

	if (rsi->cmd == C_PREREMOVE)
		add_drreq(rsi, resource_name);

	fill_argv(rsi, argv, resource_name);
	copy_env(script_env, envp);
	for (i = 0; envp[i] != NULL; i++)
		;
	envp[i++] = (flag & RCM_FORCE) ? script_env_force : script_env_noforce;
	envp[i] = NULL;

	status = do_dr(rsi, argv, envp, info);

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

/*
 * notify_online entry point
 */
/* ARGSUSED */
static int
script_notify_online(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	int status;

	rcm_log_message(RSCR_TRACE, "script_notify_online: resource = %s\n",
				resource_name);

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = C_UNDOREMOVE;
	fill_argv(rsi, argv, resource_name);

	status = do_dr(rsi, argv, script_env, info);

	remove_drreq(rsi, resource_name);

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

/*
 * notify_remove entry point
 */
/* ARGSUSED */
static int
script_notify_remove(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	int status;

	rcm_log_message(RSCR_TRACE, "script_notify_remove: resource = %s\n",
				resource_name);

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = C_POSTREMOVE;
	fill_argv(rsi, argv, resource_name);

	status = do_dr(rsi, argv, script_env, info);

	remove_drreq(rsi, resource_name);

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

/*
 * request_suspend entry point
 */
/* ARGSUSED */
static int
script_request_suspend(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	timespec_t *interval,
	uint_t flag,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *buf = NULL;
	char *curptr = NULL;
	char *argv[MAX_ARGS];
	char *envp[MAX_ENV_PARAMS];
	char flags_name[MAX_FLAGS_NAME_LEN];
	int buflen = 0;
	long seconds;
	int status;
	int i;

	rcm_log_message(RSCR_TRACE,
	    "script_request_suspend: resource = %s flags = %s\n", resource_name,
	    flags_to_name(flag, flags_name, MAX_FLAGS_NAME_LEN));

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = (flag & RCM_QUERY) ? C_QUERYSUSPEND : C_PRESUSPEND;

	if (rsi->cmd == C_PRESUSPEND)
		add_drreq(rsi, resource_name);

	fill_argv(rsi, argv, resource_name);

	copy_env(script_env, envp);
	for (i = 0; envp[i] != NULL; i++);

	envp[i++] = (flag & RCM_FORCE) ? script_env_force : script_env_noforce;

	if (interval) {
		/*
		 * Merge the seconds and nanoseconds, rounding up if there
		 * are any remainder nanoseconds.
		 */
		seconds = interval->tv_sec + (interval->tv_nsec / 1000000000L);
		if (interval->tv_nsec % 1000000000L)
			seconds += (interval->tv_sec > 0) ? 1L : -1L;
		rcmscript_snprintf(&buf, &buflen, &curptr, script_env_interval,
		    seconds);
		envp[i++] = buf;
	}

	envp[i] = NULL;

	status = do_dr(rsi, argv, envp, info);

	(void) mutex_unlock(&rsi->channel_lock);
	if (buf)
		free(buf);
	return (status);
}

/*
 * notify_resume entry point
 */
/* ARGSUSED */
static int
script_notify_resume(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	int status;

	rcm_log_message(RSCR_TRACE, "script_notify_resume: resource = %s\n",
	    resource_name);

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = (flag & RCM_SUSPENDED) ? C_POSTRESUME : C_CANCELSUSPEND;
	fill_argv(rsi, argv, resource_name);

	status = do_dr(rsi, argv, script_env, info);

	remove_drreq(rsi, resource_name);

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

static capacity_descr_t capacity_type[] = {
	{ "SUNW_memory", MATCH_EXACT,
		"new_pages", "RCM_ENV_CAPACITY",
		"page_size", "RCM_ENV_UNIT_SIZE",
		"", ""},
	{ "SUNW_cpu", MATCH_EXACT,
		"new_total", "RCM_ENV_CAPACITY",
		"new_cpu_list", "RCM_ENV_CPU_IDS",
		"", ""},
	{ "SUNW_cpu/set", MATCH_PREFIX,
		"new_total", "RCM_ENV_CAPACITY",
		"new_cpu_list", "RCM_ENV_CPU_IDS",
		"", ""},
	{ "", MATCH_INVALID, "", "" }
};

static capacity_descr_t *
get_capacity_descr(char *resource_name)
{
	int i;

	for (i = 0; *capacity_type[i].resource_name != '\0'; i++) {
		if ((capacity_type[i].match_type == MATCH_EXACT &&
			strcmp(capacity_type[i].resource_name,
			resource_name) == 0) ||
			(capacity_type[i].match_type == MATCH_PREFIX &&
			strncmp(capacity_type[i].resource_name,
			resource_name,
			strlen(capacity_type[i].resource_name)) == 0))

			return (&capacity_type[i]);
	}

	return (NULL);
}

static int
build_env_for_capacity(script_info_t *rsi,
	char *resource_name,
	uint_t flag,
	nvlist_t *capacity_info,
	char *envp[],
	int *dynamic_env_index,
	char **errmsg)
{
	int p, i;
	capacity_descr_t *capa = NULL;
	nvpair_t *nvpair;
	char *buf;
	char *curptr;
	int buflen;
	int error;
	uint_t n;

	copy_env(script_env, envp);
	for (p = 0; envp[p] != NULL; p++)
		;

	if (rsi->cmd == C_QUERYCAPACITY || rsi->cmd == C_PRECAPACITY)
		envp[p++] = (flag & RCM_FORCE) ? script_env_force :
						script_env_noforce;

	envp[p] = NULL;
	*dynamic_env_index = p;

	if ((capa = get_capacity_descr(resource_name)) == NULL) {
		*errmsg = dup_err(RCM_ERROR, MF_UNKNOWN_RSRC_ERR,
			resource_name, rsi->script_name);
		return (-1);
	}

	for (i = 0; *capa->param[i].nvname != '\0'; i++) {
		nvpair = NULL;
		while ((nvpair = nvlist_next_nvpair(capacity_info, nvpair))
				!= NULL) {
			if (strcmp(nvpair_name(nvpair),
					capa->param[i].nvname) == 0)
				break;
		}

		if (nvpair == NULL) {
			*errmsg = dup_err(RCM_ERROR, MF_NV_ERR,
				rsi->script_name);
			return (-1);
		}

		error = 0;
		buf = NULL;

		rcmscript_snprintf(&buf, &buflen, &curptr, "%s=",
				capa->param[i].envname);

		switch (nvpair_type(nvpair)) {
		case DATA_TYPE_INT16:
		{
			int16_t x;

			if (nvpair_value_int16(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%hd", (short)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT16:
		{
			uint16_t x;

			if (nvpair_value_uint16(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%hu", (unsigned short)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_INT32:
		{
			int32_t x;

			if (nvpair_value_int32(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%d", (int)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT32:
		{
			uint32_t x;

			if (nvpair_value_uint32(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%u", (uint_t)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_INT64:
		{
			int64_t x;

			if (nvpair_value_int64(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%lld", (long long)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT64:
		{
			uint64_t x;

			if (nvpair_value_uint64(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
					"%llu", (unsigned long long)x);
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_INT16_ARRAY:
		{
			int16_t *x;

			if (nvpair_value_int16_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%hd%s",
						(short)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT16_ARRAY:
		{
			uint16_t *x;

			if (nvpair_value_uint16_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%hu%s",
						(unsigned short)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_INT32_ARRAY:
		{
			int32_t *x;

			if (nvpair_value_int32_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%d%s",
						(int)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT32_ARRAY:
		{
			uint32_t *x;

			if (nvpair_value_uint32_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%u%s",
						(uint_t)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_INT64_ARRAY:
		{
			int64_t *x;

			if (nvpair_value_int64_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%lld%s",
						(long long)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_UINT64_ARRAY:
		{
			uint64_t *x;

			if (nvpair_value_uint64_array(nvpair, &x, &n) == 0) {
				while (n--) {
					rcmscript_snprintf(&buf, &buflen,
						&curptr, "%llu%s",
						(unsigned long long)(*x),
						(n == 0) ? "" : " ");
					x++;
				}
			} else
				error = 1;
			break;
		}

		case DATA_TYPE_STRING:
		{
			char *x;

			if (nvpair_value_string(nvpair, &x) == 0) {
				rcmscript_snprintf(&buf, &buflen, &curptr,
						"%s", x);
			} else
				error = 1;
			break;
		}


		default:
			error = 1;
			break;
		}

		envp[p++] = buf;

		if (error) {
			envp[p] = NULL;
			for (p = *dynamic_env_index; envp[p] != NULL; p++)
				free(envp[p]);
			*errmsg = dup_err(RCM_ERROR, MF_NV_ERR,
				rsi->script_name);
			return (-1);
		}
	}

	envp[p] = NULL;

	return (0);
}

/*
 * request_capacity_change entry point
 */
/* ARGSUSED */
static int
script_request_capacity_change(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	nvlist_t *capacity_info,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	char *envp[MAX_ENV_PARAMS];
	char flags_name[MAX_FLAGS_NAME_LEN];
	int status;
	int dynamic_env_index;

	rcm_log_message(RSCR_TRACE,
		"script_request_capacity_change: resource = %s flags = %s\n",
			resource_name,
			flags_to_name(flag, flags_name, MAX_FLAGS_NAME_LEN));

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = (flag & RCM_QUERY) ? C_QUERYCAPACITY : C_PRECAPACITY;
	fill_argv(rsi, argv, resource_name);

	if (build_env_for_capacity(rsi, resource_name, flag,
			capacity_info, envp, &dynamic_env_index, info) == 0) {

		status = do_dr(rsi, argv, envp, info);

		while (envp[dynamic_env_index] != NULL) {
			free(envp[dynamic_env_index]);
			dynamic_env_index++;
		}
	} else
		status = RCM_FAILURE;

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

/*
 * notify_capacity_change entry point
 */
/* ARGSUSED */
static int
script_notify_capacity_change(rcm_handle_t *hdl,
	char *resource_name,
	pid_t pid,
	uint_t flag,
	nvlist_t *capacity_info,
	char **info,
	rcm_info_t **dependent_info)
{
	script_info_t *rsi = hdl->module->rsi;
	char *argv[MAX_ARGS];
	char *envp[MAX_ENV_PARAMS];
	int status;
	int dynamic_env_index;

	rcm_log_message(RSCR_TRACE,
	"script_notify_capacity_change: resource = %s\n", resource_name);

	*info = NULL;

	(void) mutex_lock(&rsi->channel_lock);

	rsi->hdl = hdl;
	rsi->cmd = C_POSTCAPACITY;
	fill_argv(rsi, argv, resource_name);

	if (build_env_for_capacity(rsi, resource_name, flag,
			capacity_info, envp, &dynamic_env_index, info) == 0) {

		status = do_dr(rsi, argv, envp, info);

		while (envp[dynamic_env_index] != NULL) {
			free(envp[dynamic_env_index]);
			dynamic_env_index++;
		}
	} else
		status = RCM_FAILURE;

	(void) mutex_unlock(&rsi->channel_lock);
	return (status);
}

/* Log the message to syslog */
static void
log_msg(script_info_t *rsi, int level, char *msg)
{
	rcm_log_msg(level, MS_LOG_MSG, rsi->script_name, msg);
}

/*PRINTFLIKE2*/
static char *
dup_err(int level, char *format, ...)
{
	va_list ap;
	char buf1[1];
	char *buf2;
	int n;

	va_start(ap, format);
	n = vsnprintf(buf1, 1, format, ap);
	va_end(ap);

	if (n > 0) {
		n++;
		if (buf2 = (char *)malloc(n)) {
			va_start(ap, format);
			n = vsnprintf(buf2, n, format, ap);
			va_end(ap);
			if (n > 0) {
				if (level != -1)
					rcm_log_message(level, buf2);
				return (buf2);
			}
			free(buf2);
		}
	}

	return (NULL);
}

/*PRINTFLIKE4*/
static void
rcmscript_snprintf(char **buf, int *buflen, char **curptr, char *format, ...)
{
/* must be power of 2 otherwise RSCR_ROUNDUP would break */
#define	SPRINTF_CHUNK_LEN	512
#define	SPRINTF_MIN_CHUNK_LEN	64

	va_list ap;
	int offset, bytesneeded, bytesleft, error_num;

	if (*buf == NULL) {
		*buflen = 0;
		*curptr = NULL;
	}

	offset = *curptr - *buf;
	bytesneeded = SPRINTF_MIN_CHUNK_LEN;
	bytesleft = *buflen - offset;

	/* LINTED */
	while (1) {
		if (bytesneeded > bytesleft) {
			*buflen += RSCR_ROUNDUP(bytesneeded - bytesleft,
					SPRINTF_CHUNK_LEN);
			if ((*buf = (char *)realloc(*buf, *buflen)) == NULL) {
				error_num = errno;
				rcm_log_message(RCM_ERROR,
					MF_MEMORY_ALLOCATION_ERR,
					strerror(error_num));
				rcmd_exit(error_num);
				/*NOTREACHED*/
			}
			*curptr = *buf + offset;
			bytesleft = *buflen - offset;
		}

		va_start(ap, format);
		bytesneeded = vsnprintf(*curptr, bytesleft, format, ap);
		va_end(ap);

		if (bytesneeded < 0)  {
			/* vsnprintf encountered an error */
			error_num = errno;
			rcm_log_message(RCM_ERROR, MF_FUNC_CALL_ERR,
				"vsnprintf", strerror(error_num));
			rcmd_exit(error_num);
			/*NOTREACHED*/

		} else if (bytesneeded < bytesleft) {
			/* vsnprintf succeeded */
			*curptr += bytesneeded;
			return;

		} else {
			bytesneeded++; /* to account for storage for '\0' */
		}
	}
}

static char *
rcmscript_strdup(char *str)
{
	char *dupstr;

	if ((dupstr = strdup(str)) == NULL) {
		rcm_log_message(RCM_ERROR, MF_MEMORY_ALLOCATION_ERR,
			strerror(errno));
		rcmd_exit(errno);
		/*NOTREACHED*/
	}

	return (dupstr);
}

static void *
rcmscript_malloc(size_t len)
{
	void *ptr;

	if ((ptr = malloc(len)) == NULL) {
		rcm_log_message(RCM_ERROR, MF_MEMORY_ALLOCATION_ERR,
			strerror(errno));
		rcmd_exit(errno);
		/*NOTREACHED*/
	}

	return (ptr);
}

static void *
rcmscript_calloc(size_t nelem, size_t elsize)
{
	void *ptr;

	if ((ptr = calloc(nelem, elsize)) == NULL) {
		rcm_log_message(RCM_ERROR, MF_MEMORY_ALLOCATION_ERR,
			strerror(errno));
		rcmd_exit(errno);
		/*NOTREACHED*/
	}

	return (ptr);
}