rcm_daemon/common/rcm_script.c

/*
 * 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);
}