lib/librcm/librcm.c

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

#include "librcm_impl.h"
#include "librcm_event.h"

#ifdef  DEBUG
static int rcm_debug = 1;
#define dprintf(args) if (rcm_debug) (void) fprintf args
#else
#define dprintf(args) /* nothing */
#endif  /* DEBUG */

static int extract_info(nvlist_t *, rcm_info_t **);
static int rcm_daemon_is_alive();
static int rcm_common(int, rcm_handle_t *, char **, uint_t, void *,
    rcm_info_t **);
static int rcm_direct_call(int, rcm_handle_t *, char **, uint_t, void *,
    rcm_info_t **);
static int rcm_daemon_call(int, rcm_handle_t *, char **, uint_t, void *,
    rcm_info_t **);
static int rcm_generate_nvlist(int, rcm_handle_t *, char **, uint_t, void *,
    char **, size_t *);
static int rcm_check_permission(void);

/*
 * Allocate a handle structure
 */
/*ARGSUSED2*/
int
rcm_alloc_handle(char *modname, uint_t flag, void *arg, rcm_handle_t **hdp)
{
    rcm_handle_t *hd;
    void *temp;
    char namebuf[MAXPATHLEN];

    if ((hdp == NULL) || (flag & ~RCM_ALLOC_HDL_MASK)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    if (rcm_check_permission() == 0) {
        errno = EPERM;
        return (RCM_FAILURE);
    }

    if ((hd = calloc(1, sizeof (*hd))) == NULL) {
        return (RCM_FAILURE);
    }

    if (modname) {
        (void) snprintf(namebuf, MAXPATHLEN, "%s%s", modname,
            RCM_MODULE_SUFFIX);

        if ((hd->modname = strdup(namebuf)) == NULL) {
            free(hd);
            return (RCM_FAILURE);
        }

        if ((temp = rcm_module_open(namebuf)) == NULL) {
            free(hd->modname);
            free(hd);
            errno = EINVAL;
            return (RCM_FAILURE);
        }

        rcm_module_close(temp);
    }

    if (flag & RCM_NOPID) {
        hd->pid = (pid_t)0;
    } else {
        hd->pid = (pid_t)getpid();
    }

    *hdp = hd;
    return (RCM_SUCCESS);
}

/* free handle structure */
int
rcm_free_handle(rcm_handle_t *hd)
{
    if (hd == NULL) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    if (hd->modname) {
        free(hd->modname);
    }

    free(hd);
    return (RCM_SUCCESS);
}


/*
 * Operations which require daemon processing
 */

/* get registration and DR information from rcm_daemon */
int
rcm_get_info(rcm_handle_t *hd, char *rsrcname, uint_t flag, rcm_info_t **infop)
{
    char *rsrcnames[2];

    if ((flag & ~RCM_GET_INFO_MASK) || (infop == NULL)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    /*
     * rsrcname may be NULL if requesting dr operations or modinfo
     */
    if ((rsrcname == NULL) &&
        ((flag & RCM_DR_OPERATION|RCM_MOD_INFO) == 0)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
}

/* get registration and DR information from rcm_daemon (list version) */
int
rcm_get_info_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    rcm_info_t **infop)
{
    /* Requesting the current DR operations with a *list() is invalid */
    if ((flag & RCM_DR_OPERATION) || (flag & RCM_MOD_INFO)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
}

/* request to offline a resource before DR removal */
int
rcm_request_offline(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_request_offline_list(hd, rsrcnames, flag, infop));
}

/* request to offline a resource before DR removal (list version) */
int
rcm_request_offline_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    rcm_info_t **infop)
{
    if (flag & ~RCM_REQUEST_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_OFFLINE, hd, rsrcnames, flag, NULL, infop));
}

/* cancel offline request and allow apps to use rsrcname */
int
rcm_notify_online(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_notify_online_list(hd, rsrcnames, flag, infop));
}

/* cancel offline and allow apps to use resources (list version) */
int
rcm_notify_online_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    rcm_info_t **infop)
{
    if (flag & ~RCM_NOTIFY_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_ONLINE, hd, rsrcnames, flag, NULL, infop));
}

/* notify that rsrcname has been removed */
int
rcm_notify_remove(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_notify_remove_list(hd, rsrcnames, flag, infop));
}

/* notify that resrouces have been removed (list form) */
int
rcm_notify_remove_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    rcm_info_t **infop)
{
    if (flag & ~RCM_NOTIFY_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_REMOVE, hd, rsrcnames, flag, NULL, infop));
}

/* request for permission to suspend resource of interval time */
int
rcm_request_suspend(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    timespec_t *interval, rcm_info_t **infop)
{
    char *rsrcnames[2];

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_request_suspend_list(hd, rsrcnames, flag, interval, infop));
}

/* request for permission to suspend resource of interval time (list form) */
int
rcm_request_suspend_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    timespec_t *interval, rcm_info_t **infop)
{
    if ((flag & ~RCM_REQUEST_MASK) || (interval == NULL) ||
        (interval->tv_sec < 0) || (interval->tv_nsec < 0)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_SUSPEND, hd, rsrcnames, flag, (void *)interval,
        infop));
}

/* notify apps of the completion of resource suspension */
int
rcm_notify_resume(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_notify_resume_list(hd, rsrcnames, flag, infop));
}

/* notify apps of the completion of resource suspension (list form) */
int
rcm_notify_resume_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    rcm_info_t **infop)
{
    if (flag & ~(RCM_NOTIFY_MASK | RCM_SUSPENDED)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    return (rcm_common(CMD_RESUME, hd, rsrcnames, flag, NULL, infop));
}

/* request a capacity change from apps */
int
rcm_request_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    nvlist_t *nvl, rcm_info_t **infop)
{
    int rv;
    char *rsrcnames[2];

    if ((nvl == NULL) || (flag & ~RCM_REQUEST_MASK)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    rv = rcm_common(CMD_REQUEST_CHANGE, hd, rsrcnames, flag, (void *)nvl,
        infop);

    return (rv);
}

/* notify apps of a capacity change */
int
rcm_notify_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    nvlist_t *nvl, rcm_info_t **infop)
{
    int rv;
    char *rsrcnames[2];

    if ((nvl == NULL) || (flag & ~RCM_REQUEST_MASK)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    rv = rcm_common(CMD_NOTIFY_CHANGE, hd, rsrcnames, flag, (void *)nvl,
        infop);

    return (rv);
}

/* notify apps of an event */
int
rcm_notify_event(rcm_handle_t *hd, char *rsrcname, uint_t flag, nvlist_t *nvl,
    rcm_info_t **infop)
{
    int rv;
    char *rsrcnames[2];

    /* No flags are defined yet for rcm_notify_event() */
    if ((nvl == NULL) || (flag != 0)) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    rv = rcm_common(CMD_EVENT, hd, rsrcnames, 0, (void *)nvl, infop);

    return (rv);
}

/*
 * Register to receive capacity changes. This requires a module to exist in
 * module directory. It should be called prior to using a new resource.
 */
/* ARGSUSED */
int
rcm_register_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_CAPACITY;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/* unregister interest in capacity changes */
int
rcm_unregister_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_CAPACITY;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/*
 * Register to receive events. This requires a module to exist in module
 * directory. It should be called prior to using a new resource.
 */
/* ARGSUSED */
int
rcm_register_event(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_EVENT;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/* unregister interest in events */
int
rcm_unregister_event(rcm_handle_t *hd, char *rsrcname, uint_t flag)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_EVENT;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/*
 * Register interest in a resource. This requires a module to exist in module
 * directory. It should be called prior to using a new resource.
 *
 * Registration may be denied if it is presently locked by a DR operation.
 */
/* ARGSUSED */
int
rcm_register_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag,
    rcm_info_t **infop)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_DR;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/* unregister interest in rsrcname */
int
rcm_unregister_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag)
{
    char *rsrcnames[2];

    if (flag & ~RCM_REGISTER_MASK) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    flag |= RCM_REGISTER_DR;

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
}

/* get the current state of a resource */
int
rcm_get_rsrcstate(rcm_handle_t *hd, char *rsrcname, int *statep)
{
    int result;
    int flag = 0;
    rcm_info_t *infop = NULL;
    rcm_info_tuple_t *tuple = NULL;
    char *rsrcnames[2];

    if (statep == NULL) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    rsrcnames[0] = rsrcname;
    rsrcnames[1] = NULL;

    result = rcm_common(CMD_GETSTATE, hd, rsrcnames, flag, NULL, &infop);

    /*
     * A successful result implies the presence of exactly one RCM info
     * tuple containing the state of this resource (a combination of each
     * client's resources).  If that's not true, change the result to
     * RCM_FAILURE.
     */
    if (result == RCM_SUCCESS) {
        if ((infop == NULL) ||
            ((tuple = rcm_info_next(infop, NULL)) == NULL) ||
            (rcm_info_next(infop, tuple) != NULL)) {
            result = RCM_FAILURE;
        } else if (infop && tuple) {
            *statep = rcm_info_state(tuple);
        }
    }

    if (infop)
        rcm_free_info(infop);

    return (result);
}

/*
 * RCM helper functions exposed to librcm callers.
 */

/* Free linked list of registration info */
void
rcm_free_info(rcm_info_t *info)
{
    while (info) {
        rcm_info_t *tmp = info->next;

        nvlist_free(info->info);
        free(info);

        info = tmp;
    }
}

/* return the next tuple in the info structure */
rcm_info_tuple_t *
rcm_info_next(rcm_info_t *info, rcm_info_tuple_t *tuple)
{
    if (info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (tuple == NULL) {
        return ((rcm_info_tuple_t *)info);
    }
    return ((rcm_info_tuple_t *)tuple->next);
}

/* return resource name */
const char *
rcm_info_rsrc(rcm_info_tuple_t *tuple)
{
    char *rsrcname = NULL;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (errno = nvlist_lookup_string(tuple->info, RCM_RSRCNAME, &rsrcname))
        return (NULL);

    return (rsrcname);
}

const char *
rcm_info_info(rcm_info_tuple_t *tuple)
{
    char *info = NULL;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_INFO, &info))
        return (NULL);

    return (info);
}

const char *
rcm_info_error(rcm_info_tuple_t *tuple)
{
    char *errstr = NULL;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_ERROR,
        &errstr))
        return (NULL);

    return (errstr);
}

/* return info string in the tuple */
const char *
rcm_info_modname(rcm_info_tuple_t *tuple)
{
    char *modname = NULL;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_MODNAME,
        &modname))
        return (NULL);

    return (modname);
}

/* return client pid in the tuple */
pid_t
rcm_info_pid(rcm_info_tuple_t *tuple)
{
    uint64_t pid64 = (uint64_t)0;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return ((pid_t)0);
    }

    if (errno = nvlist_lookup_uint64(tuple->info, RCM_CLIENT_ID, &pid64))
        return ((pid_t)0);

    return ((pid_t)pid64);
}

/* return client state in the tuple */
int
rcm_info_state(rcm_info_tuple_t *tuple)
{
    int state;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (RCM_STATE_UNKNOWN);
    }

    if (errno = nvlist_lookup_int32(tuple->info, RCM_RSRCSTATE, &state))
        return (RCM_STATE_UNKNOWN);

    return (state);
}

/* return the generic properties in the tuple */
nvlist_t *
rcm_info_properties(rcm_info_tuple_t *tuple)
{
    char *buf;
    uint_t buflen;
    nvlist_t *nvl;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (NULL);
    }

    if (errno = nvlist_lookup_byte_array(tuple->info, RCM_CLIENT_PROPERTIES,
        (uchar_t **)&buf, &buflen))
        return (NULL);

    if (errno = nvlist_unpack(buf, buflen, &nvl, 0)) {
        free(buf);
        return (NULL);
    }

    return (nvl);
}

/*
 * return operation sequence number
 *
 * This is private. Called by rcmctl only for testing purposes.
 */
int
rcm_info_seqnum(rcm_info_tuple_t *tuple)
{
    int seqnum;

    if (tuple == NULL || tuple->info == NULL) {
        errno = EINVAL;
        return (-1);
    }

    if (errno = nvlist_lookup_int32(tuple->info, RCM_SEQ_NUM, &seqnum))
        return (-1);

    return (seqnum);
}


/*
 * The following interfaces are PRIVATE to the RCM framework. They are not
 * declared static because they are called by rcm_daemon.
 */

/*
 * Invoke shell to execute command in MT safe manner.
 * Returns wait status or -1 on error.
 */
int
rcm_exec_cmd(char *cmd)
{
    pid_t pid;
    int status, w;
    char *argvec[] = {"sh", "-c", NULL, NULL};

    argvec[2] = cmd;
    if ((pid = fork1()) == 0) {
        (void) execv("/bin/sh", argvec);
        _exit(127);
    } else if (pid == -1) {
        return (-1);
    }

    do {
        w = waitpid(pid, &status, 0);
    } while (w == -1 && errno == EINTR);

    return ((w == -1) ? w : status);
}

/* Append info at the very end */
int
rcm_append_info(rcm_info_t **head, rcm_info_t *info)
{
    rcm_info_t *tuple;

    if (head == NULL) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    if ((tuple = *head) == NULL) {
        *head = info;
        return (RCM_SUCCESS);
    }

    while (tuple->next) {
        tuple = tuple->next;
    }
    tuple->next = info;
    return (RCM_SUCCESS);
}

/* get rcm module and rcm script directory names */

#define N_MODULE_DIR    3   /* search 3 directories for modules */
#define MODULE_DIR_HW   "/usr/platform/%s/lib/rcm/modules/"
#define MODULE_DIR_GEN  "/usr/lib/rcm/modules/"

#define N_SCRIPT_DIR    4   /* search 4 directories for scripts */
#define SCRIPT_DIR_HW   "/usr/platform/%s/lib/rcm/scripts/"
#define SCRIPT_DIR_GEN  "/usr/lib/rcm/scripts/"
#define SCRIPT_DIR_ETC  "/etc/rcm/scripts/"


char *
rcm_module_dir(uint_t dirnum)
{
    if (dirnum < N_MODULE_DIR)
        return (rcm_dir(dirnum, NULL));
    else
        return (NULL);
}

char *
rcm_script_dir(uint_t dirnum)
{
    if (dirnum < N_SCRIPT_DIR)
        return (rcm_dir(dirnum + N_MODULE_DIR, NULL));
    else
        return (NULL);
}

char *
rcm_dir(uint_t dirnum, int *rcm_script)
{
    static char dir_name[N_MODULE_DIR + N_SCRIPT_DIR][MAXPATHLEN];

    char infobuf[MAXPATHLEN];

    if (dirnum >= (N_MODULE_DIR + N_SCRIPT_DIR))
        return (NULL);

    if (dir_name[0][0] == '\0') {
        /*
         * construct the module directory names
         */
        if (sysinfo(SI_PLATFORM, infobuf, MAXPATHLEN) == -1) {
            dprintf((stderr, "sysinfo %s\n", strerror(errno)));
            return (NULL);
        } else {
            if (snprintf(dir_name[0], MAXPATHLEN, MODULE_DIR_HW,
                infobuf) >= MAXPATHLEN ||
                snprintf(dir_name[N_MODULE_DIR + 1], MAXPATHLEN,
                SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
                dprintf((stderr,
                    "invalid module or script directory for "
                    "platform %s\n", infobuf));
                return (NULL);
            }
        }

        if (sysinfo(SI_MACHINE, infobuf, MAXPATHLEN) == -1) {
            dprintf((stderr, "sysinfo %s\n", strerror(errno)));
            return (NULL);
        } else {
            if (snprintf(dir_name[1], MAXPATHLEN, MODULE_DIR_HW,
                infobuf) >= MAXPATHLEN ||
                snprintf(dir_name[N_MODULE_DIR + 2], MAXPATHLEN,
                SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
                dprintf((stderr,
                    "invalid module or script directory for "
                    "machine type %s\n", infobuf));
                return (NULL);
            }
        }

        if (strlcpy(dir_name[2], MODULE_DIR_GEN, MAXPATHLEN) >=
            MAXPATHLEN ||
            strlcpy(dir_name[N_MODULE_DIR + 3], SCRIPT_DIR_GEN,
            MAXPATHLEN) >= MAXPATHLEN ||
            strlcpy(dir_name[N_MODULE_DIR + 0], SCRIPT_DIR_ETC,
            MAXPATHLEN) >= MAXPATHLEN) {
            dprintf((stderr,
                "invalid module or script generic directory\n"));
            return (NULL);
        }
    }

    if (rcm_script)
        *rcm_script = (dirnum < N_MODULE_DIR) ? 0 : 1;

    return (dir_name[dirnum]);
}

/*
 * Find the directory where the script is located.
 * If the script is found return a pointer to the directory where the
 * script was found otherwise return NULL.
 */
char *
rcm_get_script_dir(char *script_name)
{
    uint_t i;
    char *dir_name;
    char path[MAXPATHLEN];
    struct stat stats;

    for (i = 0; (dir_name = rcm_script_dir(i)) != NULL; i++) {
        if (snprintf(path, MAXPATHLEN, "%s%s", dir_name, script_name)
            >= MAXPATHLEN) {
            dprintf((stderr, "invalid script %s skipped\n",
                script_name));
            continue;
        }
        if (stat(path, &stats) == 0)
            return (dir_name);
    }

    return (NULL);
}

/*
 * Returns 1 if the filename is an rcm script.
 * Returns 0 if the filename is an rcm module.
 */
int
rcm_is_script(char *filename)
{
    char *tmp;

    if (((tmp = strstr(filename, RCM_MODULE_SUFFIX)) != NULL) &&
        (tmp[strlen(RCM_MODULE_SUFFIX)] == '\0'))
        return (0);
    else
        return (1);
}

/* Locate the module and call dlopen */
void *
rcm_module_open(char *modname)
{
    unsigned i;
    char *dir_name;
    void *dlhandle = NULL;
    char modpath[MAXPATHLEN];

#ifdef DEBUG
    struct stat sbuf;
#endif

    /*
     * dlopen the module
     */
    for (i = 0; (dir_name = rcm_module_dir(i)) != NULL; i++) {
        if (snprintf(modpath, MAXPATHLEN, "%s%s", dir_name, modname)
            >= MAXPATHLEN) {
            dprintf((stderr, "invalid module %s skipped\n",
                modname));
            continue;
        }

        if ((dlhandle = dlopen(modpath, RTLD_LAZY)) != NULL) {
            return (dlhandle);
        }

        dprintf((stderr, "failure (dlopen=%s)\n", dlerror()));
#ifdef DEBUG
        if (stat(modpath, &sbuf) == 0) {
            (void) fprintf(stderr, "%s is not a valid module\n",
                modpath);
        }
#endif
    }

    dprintf((stderr, "module %s not found\n", modname));
    return (NULL);
}

/* dlclose module */
void
rcm_module_close(void *dlhandle)
{
    if (dlclose(dlhandle) == 0)
        return;

    dprintf((stderr, "dlclose: %s\n", dlerror()));
}


/*
 * stub implementation of rcm_log_message allows dlopen of rcm modules
 * to proceed in absence of rcm_daemon.
 *
 * This definition is interposed by the definition in rcm_daemon because of the
 * default search order implemented by the linker and dlsym(). All RCM modules
 * will see the daemon version when loaded by the rcm_daemon.
 */
/* ARGSUSED */
void
rcm_log_message(int level, char *message, ...)
{
    dprintf((stderr, "rcm_log_message stub\n"));
}

/*
 * Helper functions
 */

/*
 * Common routine for all rcm calls which require daemon processing
 */
static int
rcm_common(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag, void *arg,
    rcm_info_t **infop)
{
    int i;

    if (hd == NULL) {
        errno = EINVAL;
        return (RCM_FAILURE);
    }

    if (getuid() != 0) {
        errno = EPERM;
        return (RCM_FAILURE);
    }

    if ((flag & (RCM_DR_OPERATION | RCM_MOD_INFO)) == 0) {
        if ((rsrcnames == NULL) || (rsrcnames[0] == NULL)) {
            errno = EINVAL;
            return (RCM_FAILURE);
        }

        for (i = 0; rsrcnames[i] != NULL; i++) {
            if (*rsrcnames[i] == '\0') {
                errno = EINVAL;
                return (RCM_FAILURE);
            }
        }
    }

    /*
     * Check if handle is allocated by rcm_daemon. If so, this call came
     * from an RCM module, so we make a direct call into rcm_daemon.
     */
    if (hd->lrcm_ops != NULL) {
        return (rcm_direct_call(cmd, hd, rsrcnames, flag, arg, infop));
    }

    /*
     * When not called from a RCM module (i.e. no recursion), zero the
     * pointer just in case caller did not do so. For recursive calls,
     * we want to append rcm_info_t after infop; zero it may cause
     * memory leaks.
     */
    if (infop) {
        *infop = NULL;
    }

    /*
     * Now call into the daemon.
     */
    return (rcm_daemon_call(cmd, hd, rsrcnames, flag, arg, infop));
}

/*
 * Caller is an RCM module, call directly into rcm_daemon.
 */
static int
rcm_direct_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    void *arg, rcm_info_t **infop)
{
    int error;

    librcm_ops_t *ops = (librcm_ops_t *)hd->lrcm_ops;
    switch (cmd) {
    case CMD_GETINFO:
        error = ops->librcm_getinfo(rsrcnames, flag, hd->seq_num,
            infop);
        break;

    case CMD_OFFLINE:
        error = ops->librcm_offline(rsrcnames, hd->pid, flag,
            hd->seq_num, infop);
        break;

    case CMD_ONLINE:
        error = ops->librcm_online(rsrcnames, hd->pid, flag,
            hd->seq_num, infop);
        break;

    case CMD_REMOVE:
        error = ops->librcm_remove(rsrcnames, hd->pid, flag,
            hd->seq_num, infop);
        break;

    case CMD_SUSPEND:
        error = ops->librcm_suspend(rsrcnames, hd->pid, flag,
            hd->seq_num, (timespec_t *)arg, infop);
        break;

    case CMD_RESUME:
        error = ops->librcm_resume(rsrcnames, hd->pid, flag,
            hd->seq_num, infop);
        break;

    case CMD_REGISTER:
        error = ops->librcm_regis(hd->modname, rsrcnames[0], hd->pid,
            flag, infop);
        break;

    case CMD_UNREGISTER:
        error = ops->librcm_unregis(hd->modname, rsrcnames[0], hd->pid,
            flag);
        break;

    case CMD_REQUEST_CHANGE:
        error = ops->librcm_request_change(rsrcnames[0], hd->pid, flag,
            hd->seq_num, (nvlist_t *)arg, infop);
        break;

    case CMD_NOTIFY_CHANGE:
        error = ops->librcm_notify_change(rsrcnames[0], hd->pid, flag,
            hd->seq_num, (nvlist_t *)arg, infop);
        break;

    case CMD_EVENT:
        error = ops->librcm_notify_event(rsrcnames[0], hd->pid, flag,
            hd->seq_num, (nvlist_t *)arg, infop);
        break;

    case CMD_GETSTATE:
        error = ops->librcm_getstate(rsrcnames[0], hd->pid, infop);
        break;

    default:
        dprintf((stderr, "invalid command: %d\n", cmd));
        error = EFAULT;
    }

    if (error > 0) {
        errno = error;
        error = RCM_FAILURE;
    }
    return (error);
}

/*
 * Call into rcm_daemon door to process the request
 */
static int
rcm_daemon_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    void *arg, rcm_info_t **infop)
{
    int errno_found;
    int daemon_errno = 0;
    int error = RCM_SUCCESS;
    int delay = 300;
    int maxdelay = 10000;   /* 10 seconds */
    char *nvl_packed = NULL;
    size_t nvl_size = 0;
    nvlist_t *ret = NULL;
    nvpair_t *nvp;
    size_t rsize = 0;
    rcm_info_t *info = NULL;

    errno = 0;

    /*
     * Decide whether to start the daemon
     */
    switch (cmd) {
    case CMD_GETINFO:
    case CMD_OFFLINE:
    case CMD_ONLINE:
    case CMD_REMOVE:
    case CMD_SUSPEND:
    case CMD_RESUME:
    case CMD_REGISTER:
    case CMD_UNREGISTER:
    case CMD_EVENT:
    case CMD_REQUEST_CHANGE:
    case CMD_NOTIFY_CHANGE:
    case CMD_GETSTATE:
        break;

    default:
        errno = EFAULT;
        return (RCM_FAILURE);
    }

    if (rcm_daemon_is_alive() != 1) {
        dprintf((stderr, "failed to start rcm_daemon\n"));
        errno = EFAULT;
        return (RCM_FAILURE);
    }

    /*
     * Generate a packed nvlist for the request
     */
    if (rcm_generate_nvlist(cmd, hd, rsrcnames, flag, arg, &nvl_packed,
        &nvl_size) < 0) {
        dprintf((stderr, "error in nvlist generation\n"));
        errno = EFAULT;
        return (RCM_FAILURE);
    }

    /*
     * Make the door call and get a return event. We go into a retry loop
     * when RCM_ET_EAGAIN is returned.
     */
retry:
    if (get_event_service(RCM_SERVICE_DOOR, (void *)nvl_packed, nvl_size,
        (void **)&ret, &rsize) < 0) {
        dprintf((stderr, "rcm_daemon call failed: %s\n",
            strerror(errno)));
        free(nvl_packed);
        return (RCM_FAILURE);
    }

    assert(ret != NULL);

    /*
     * nvlist_lookup_* routines don't work because the returned nvlist
     * was nvlist_alloc'ed without the NV_UNIQUE_NAME flag.  Implement
     * a sequential search manually, which is fine since there is only
     * one RCM_RESULT value in the nvlist.
     */
    errno_found = 0;
    nvp = NULL;
    while (nvp = nvlist_next_nvpair(ret, nvp)) {
        if (strcmp(nvpair_name(nvp), RCM_RESULT) == 0) {
            if (errno = nvpair_value_int32(nvp, &daemon_errno)) {
                error = RCM_FAILURE;
                goto out;
            }
            errno_found++;
            break;
        }
    }
    if (errno_found == 0) {
        errno = EFAULT;
        error = RCM_FAILURE;
        goto out;
    }

    if (daemon_errno == EAGAIN) {
        /*
         * Wait and retry
         */
        dprintf((stderr, "retry door_call\n"));

        if (delay > maxdelay) {
            errno = EAGAIN;
            error = RCM_FAILURE;
            goto out;
        }

        (void) poll(NULL, 0, delay);
        delay *= 2;     /* exponential back off */
        nvlist_free(ret);
        goto retry;
    }

    /*
     * The door call succeeded. Now extract info from returned event.
     */
    if (extract_info(ret, &info) != 0) {
        dprintf((stderr, "error in extracting event data\n"));
        errno = EFAULT;
        error = RCM_FAILURE;
        goto out;
    }

    if (infop)
        *infop = info;
    else
        rcm_free_info(info);

    if (daemon_errno) {
        if (daemon_errno > 0) {
            errno = daemon_errno;
            error = RCM_FAILURE;
        } else {
            error = daemon_errno;
        }
    }

out:
    if (nvl_packed)
        free(nvl_packed);
    nvlist_free(ret);
    dprintf((stderr, "daemon call is done. error = %d, errno = %s\n", error,
        strerror(errno)));
    return (error);
}

/*
 * Extract registration info from event data.
 * Return 0 on success and -1 on failure.
 */
static int
extract_info(nvlist_t *nvl, rcm_info_t **infop)
{
    rcm_info_t *info = NULL;
    rcm_info_t *prev = NULL;
    rcm_info_t *tmp = NULL;
    char *buf;
    uint_t buflen;
    nvpair_t *nvp = NULL;

    while (nvp = nvlist_next_nvpair(nvl, nvp)) {

        buf = NULL;
        buflen = 0;

        if (strcmp(nvpair_name(nvp), RCM_RESULT_INFO) != 0)
            continue;

        if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
            dprintf((stderr, "out of memory\n"));
            goto fail;
        }

        if (errno = nvpair_value_byte_array(nvp, (uchar_t **)&buf,
            &buflen)) {
            free(tmp);
            dprintf((stderr, "failed (nvpair_value=%s)\n",
                strerror(errno)));
            goto fail;
        }
        if (errno = nvlist_unpack(buf, buflen, &(tmp->info), 0)) {
            free(tmp);
            dprintf((stderr, "failed (nvlist_unpack=%s)\n",
                strerror(errno)));
            goto fail;
        }

        if (info == NULL) {
            prev = info = tmp;
        } else {
            prev->next = tmp;
            prev = tmp;
        }
    }

    *infop = info;
    return (0);

fail:
    rcm_free_info(info);
    *infop = NULL;
    return (-1);
}

/* Generate a packed nvlist for communicating with RCM daemon */
static int
rcm_generate_nvlist(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
    void *arg, char **nvl_packed, size_t *nvl_size)
{
    int nrsrcnames;
    char *buf = NULL;
    size_t buflen = 0;
    nvlist_t *nvl = NULL;

    assert((nvl_packed != NULL) && (nvl_size != NULL));

    *nvl_size = 0;
    *nvl_packed = NULL;

    /* Allocate an empty nvlist */
    if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) > 0) {
        dprintf((stderr, "failed (nvlist_alloc=%s).\n",
            strerror(errno)));
        return (-1);
    }

    /* Stuff in all the arguments for the daemon call */
    if (nvlist_add_int32(nvl, RCM_CMD, cmd) != 0) {
        dprintf((stderr, "failed (nvlist_add(CMD)=%s).\n",
            strerror(errno)));
        goto fail;
    }
    if (rsrcnames) {
        nrsrcnames = 0;
        while (rsrcnames[nrsrcnames] != NULL)
            nrsrcnames++;
        if (nvlist_add_string_array(nvl, RCM_RSRCNAMES, rsrcnames,
            nrsrcnames) != 0) {
            dprintf((stderr, "failed (nvlist_add(RSRCNAMES)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (hd->modname) {
        if (nvlist_add_string(nvl, RCM_CLIENT_MODNAME, hd->modname)
            != 0) {
            dprintf((stderr,
                "failed (nvlist_add(CLIENT_MODNAME)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (hd->pid) {
        if (nvlist_add_uint64(nvl, RCM_CLIENT_ID, hd->pid) != 0) {
            dprintf((stderr, "failed (nvlist_add(CLIENT_ID)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (flag) {
        if (nvlist_add_uint32(nvl, RCM_REQUEST_FLAG, flag) != 0) {
            dprintf((stderr,
                "failed (nvlist_add(REQUEST_FLAG)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (arg && cmd == CMD_SUSPEND) {
        if (nvlist_add_byte_array(nvl, RCM_SUSPEND_INTERVAL,
            (uchar_t *)arg, sizeof (timespec_t)) != 0) {
            dprintf((stderr,
                "failed (nvlist_add(SUSPEND_INTERVAL)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (arg &&
        ((cmd == CMD_REQUEST_CHANGE) || (cmd == CMD_NOTIFY_CHANGE))) {
        if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
            0)) {
            dprintf((stderr,
                "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
                strerror(errno)));
            goto fail;
        }
        if (nvlist_add_byte_array(nvl, RCM_CHANGE_DATA, (uchar_t *)buf,
            buflen) != 0) {
            dprintf((stderr,
                "failed (nvlist_add(CHANGE_DATA)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }
    if (arg && cmd == CMD_EVENT) {
        if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
            0)) {
            dprintf((stderr,
                "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
                strerror(errno)));
            goto fail;
        }
        if (nvlist_add_byte_array(nvl, RCM_EVENT_DATA, (uchar_t *)buf,
            buflen) != 0) {
            dprintf((stderr,
                "failed (nvlist_add(EVENT_DATA)=%s).\n",
                strerror(errno)));
            goto fail;
        }
    }

    /* Pack the nvlist */
    if (errno = nvlist_pack(nvl, nvl_packed, nvl_size, NV_ENCODE_NATIVE,
        0)) {
        dprintf((stderr, "failed (nvlist_pack=%s).\n",
            strerror(errno)));
        goto fail;
    }

    /* If an argument was packed intermediately, free the buffer */
    if (buf)
        free(buf);

    /* Free the unpacked version of the nvlist and return the packed list */
    nvlist_free(nvl);
    return (0);

fail:
    if (buf)
        free(buf);
    nvlist_free(nvl);
    if (*nvl_packed)
        free(*nvl_packed);
    *nvl_packed = NULL;
    *nvl_size = 0;
    return (-1);
}

/* check if rcm_daemon is up and running */
static int
rcm_daemon_is_alive()
{
    int lasttry;
    struct stat st;
    nvlist_t *nvl;
    char *buf = NULL;
    size_t buflen = 0;
    int delay = 300;
    const int maxdelay = 10000; /* 10 sec */

    /* generate a packed nvlist for the door knocking */
    if (errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) {
        dprintf((stderr, "nvlist_alloc failed: %s\n", strerror(errno)));
        return (0);
    }
    if (errno = nvlist_add_int32(nvl, RCM_CMD, CMD_KNOCK)) {
        dprintf((stderr, "nvlist_add failed: %s\n", strerror(errno)));
        nvlist_free(nvl);
        return (0);
    }
    if (errno = nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0)) {
        dprintf((stderr, "nvlist_pack failed: %s\n", strerror(errno)));
        nvlist_free(nvl);
        return (0);
    }
    nvlist_free(nvl);

    /*
     * check the door and knock on it
     */
    if ((stat(RCM_SERVICE_DOOR, &st) == 0) &&
        (get_event_service(RCM_SERVICE_DOOR, (void *)buf, buflen, NULL,
        NULL) == 0)) {
        free(buf);
        return (1); /* daemon is alive */
    }

    /*
     * Attempt to start the daemon.
     * If caller has SIGCHLD set to SIG_IGN or its SA_NOCLDWAIT
     * flag set, waitpid(2) (hence rcm_exec_cmd) will fail.
     * get_event_service will determine if the rcm_daemon started.
     */
    dprintf((stderr, "exec: %s\n", RCM_DAEMON_START));
    (void) rcm_exec_cmd(RCM_DAEMON_START);

    /*
     * Wait for daemon to respond, timeout at 10 sec
     */
    while (((lasttry = get_event_service(RCM_SERVICE_DOOR, (void *)buf,
        buflen, NULL, NULL)) != 0) &&
        ((errno == EBADF) || (errno == ESRCH))) {
        if (delay > maxdelay) {
            break;
        }
        (void) poll(NULL, 0, delay);
        delay *= 2;
    }

    free(buf);
    if (lasttry == 0)
        return (1);
    return (0);
}

/*
 * Check permission.
 *
 * The policy is root only for now. Need to relax this when interface level
 * is raised.
 */
static int
rcm_check_permission(void)
{
    return (getuid() == 0);
}

/*
 * Project private function - for use by RCM MSTC tests
 *
 * Get the client name (rcm module name or script name) corresponding to
 * the given rcm handle.
 */
const char *
rcm_get_client_name(rcm_handle_t *hd)
{
    return (hd->modname);
}