2N/A/*
2N/A * CDDL HEADER START
2N/A *
2N/A * The contents of this file are subject to the terms of the
2N/A * Common Development and Distribution License (the "License").
2N/A * You may not use this file except in compliance with the License.
2N/A *
2N/A * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
2N/A * or http://www.opensolaris.org/os/licensing.
2N/A * See the License for the specific language governing permissions
2N/A * and limitations under the License.
2N/A *
2N/A * When distributing Covered Code, include this CDDL HEADER in each
2N/A * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
2N/A * If applicable, add the following below this CDDL HEADER, with the
2N/A * fields enclosed by brackets "[]" replaced with your own identifying
2N/A * information: Portions Copyright [yyyy] [name of copyright owner]
2N/A *
2N/A * CDDL HEADER END
2N/A */
2N/A/*
2N/A * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
2N/A */
2N/A
2N/A#include "librcm_impl.h"
2N/A#include "librcm_event.h"
2N/A
2N/A#ifdef DEBUG
2N/Astatic int rcm_debug = 1;
2N/A#define dprintf(args) if (rcm_debug) (void) fprintf args
2N/A#else
2N/A#define dprintf(args) /* nothing */
2N/A#endif /* DEBUG */
2N/A
2N/Astatic int extract_info(nvlist_t *, rcm_info_t **);
2N/Astatic int rcm_daemon_is_alive();
2N/Astatic int rcm_common(int, rcm_handle_t *, char **, uint_t, void *,
2N/A rcm_info_t **);
2N/Astatic int rcm_direct_call(int, rcm_handle_t *, char **, uint_t, void *,
2N/A rcm_info_t **);
2N/Astatic int rcm_daemon_call(int, rcm_handle_t *, char **, uint_t, void *,
2N/A rcm_info_t **);
2N/Astatic int rcm_generate_nvlist(int, rcm_handle_t *, char **, uint_t, void *,
2N/A char **, size_t *);
2N/Astatic int rcm_check_permission(void);
2N/A
2N/A/*
2N/A * Allocate a handle structure
2N/A */
2N/A/*ARGSUSED2*/
2N/Aint
2N/Arcm_alloc_handle(char *modname, uint_t flag, void *arg, rcm_handle_t **hdp)
2N/A{
2N/A rcm_handle_t *hd;
2N/A void *temp;
2N/A char namebuf[MAXPATHLEN];
2N/A
2N/A if ((hdp == NULL) || (flag & ~RCM_ALLOC_HDL_MASK)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if (rcm_check_permission() == 0) {
2N/A errno = EPERM;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if ((hd = calloc(1, sizeof (*hd))) == NULL) {
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if (modname) {
2N/A (void) snprintf(namebuf, MAXPATHLEN, "%s%s", modname,
2N/A RCM_MODULE_SUFFIX);
2N/A
2N/A if ((hd->modname = strdup(namebuf)) == NULL) {
2N/A free(hd);
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if ((temp = rcm_module_open(namebuf)) == NULL) {
2N/A free(hd->modname);
2N/A free(hd);
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rcm_module_close(temp);
2N/A }
2N/A
2N/A if (flag & RCM_NOPID) {
2N/A hd->pid = (pid_t)0;
2N/A } else {
2N/A hd->pid = (pid_t)getpid();
2N/A }
2N/A
2N/A *hdp = hd;
2N/A return (RCM_SUCCESS);
2N/A}
2N/A
2N/A/* free handle structure */
2N/Aint
2N/Arcm_free_handle(rcm_handle_t *hd)
2N/A{
2N/A if (hd == NULL) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if (hd->modname) {
2N/A free(hd->modname);
2N/A }
2N/A
2N/A free(hd);
2N/A return (RCM_SUCCESS);
2N/A}
2N/A
2N/A
2N/A/*
2N/A * Operations which require daemon processing
2N/A */
2N/A
2N/A/* get registration and DR information from rcm_daemon */
2N/Aint
2N/Arcm_get_info(rcm_handle_t *hd, char *rsrcname, uint_t flag, rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if ((flag & ~RCM_GET_INFO_MASK) || (infop == NULL)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A /*
2N/A * rsrcname may be NULL if requesting dr operations or modinfo
2N/A */
2N/A if ((rsrcname == NULL) &&
2N/A ((flag & RCM_DR_OPERATION|RCM_MOD_INFO) == 0)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* get registration and DR information from rcm_daemon (list version) */
2N/Aint
2N/Arcm_get_info_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A /* Requesting the current DR operations with a *list() is invalid */
2N/A if ((flag & RCM_DR_OPERATION) || (flag & RCM_MOD_INFO)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_GETINFO, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* request to offline a resource before DR removal */
2N/Aint
2N/Arcm_request_offline(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_request_offline_list(hd, rsrcnames, flag, infop));
2N/A}
2N/A
2N/A/* request to offline a resource before DR removal (list version) */
2N/Aint
2N/Arcm_request_offline_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A if (flag & ~RCM_REQUEST_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_OFFLINE, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* cancel offline request and allow apps to use rsrcname */
2N/Aint
2N/Arcm_notify_online(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_notify_online_list(hd, rsrcnames, flag, infop));
2N/A}
2N/A
2N/A/* cancel offline and allow apps to use resources (list version) */
2N/Aint
2N/Arcm_notify_online_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A if (flag & ~RCM_NOTIFY_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_ONLINE, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* notify that rsrcname has been removed */
2N/Aint
2N/Arcm_notify_remove(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_notify_remove_list(hd, rsrcnames, flag, infop));
2N/A}
2N/A
2N/A/* notify that resrouces have been removed (list form) */
2N/Aint
2N/Arcm_notify_remove_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A if (flag & ~RCM_NOTIFY_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_REMOVE, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* request for permission to suspend resource of interval time */
2N/Aint
2N/Arcm_request_suspend(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A timespec_t *interval, rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_request_suspend_list(hd, rsrcnames, flag, interval, infop));
2N/A}
2N/A
2N/A/* request for permission to suspend resource of interval time (list form) */
2N/Aint
2N/Arcm_request_suspend_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A timespec_t *interval, rcm_info_t **infop)
2N/A{
2N/A if ((flag & ~RCM_REQUEST_MASK) || (interval == NULL) ||
2N/A (interval->tv_sec < 0) || (interval->tv_nsec < 0)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_SUSPEND, hd, rsrcnames, flag, (void *)interval,
2N/A infop));
2N/A}
2N/A
2N/A/* notify apps of the completion of resource suspension */
2N/Aint
2N/Arcm_notify_resume(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_notify_resume_list(hd, rsrcnames, flag, infop));
2N/A}
2N/A
2N/A/* notify apps of the completion of resource suspension (list form) */
2N/Aint
2N/Arcm_notify_resume_list(rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A if (flag & ~(RCM_NOTIFY_MASK | RCM_SUSPENDED)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A return (rcm_common(CMD_RESUME, hd, rsrcnames, flag, NULL, infop));
2N/A}
2N/A
2N/A/* request a capacity change from apps */
2N/Aint
2N/Arcm_request_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A nvlist_t *nvl, rcm_info_t **infop)
2N/A{
2N/A int rv;
2N/A char *rsrcnames[2];
2N/A
2N/A if ((nvl == NULL) || (flag & ~RCM_REQUEST_MASK)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A rv = rcm_common(CMD_REQUEST_CHANGE, hd, rsrcnames, flag, (void *)nvl,
2N/A infop);
2N/A
2N/A return (rv);
2N/A}
2N/A
2N/A/* notify apps of a capacity change */
2N/Aint
2N/Arcm_notify_capacity_change(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A nvlist_t *nvl, rcm_info_t **infop)
2N/A{
2N/A int rv;
2N/A char *rsrcnames[2];
2N/A
2N/A if ((nvl == NULL) || (flag & ~RCM_NOTIFY_MASK)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A rv = rcm_common(CMD_NOTIFY_CHANGE, hd, rsrcnames, flag, (void *)nvl,
2N/A infop);
2N/A
2N/A return (rv);
2N/A}
2N/A
2N/A/* notify apps of an event */
2N/Aint
2N/Arcm_notify_event(rcm_handle_t *hd, char *rsrcname, uint_t flag, nvlist_t *nvl,
2N/A rcm_info_t **infop)
2N/A{
2N/A int rv;
2N/A char *rsrcnames[2];
2N/A
2N/A /* No flags are defined yet for rcm_notify_event() */
2N/A if ((nvl == NULL) || (flag != 0)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A rv = rcm_common(CMD_EVENT, hd, rsrcnames, 0, (void *)nvl, infop);
2N/A
2N/A return (rv);
2N/A}
2N/A
2N/A/*
2N/A * Register to receive capacity changes. This requires a module to exist in
2N/A * module directory. It should be called prior to using a new resource.
2N/A */
2N/A/* ARGSUSED */
2N/Aint
2N/Arcm_register_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_CAPACITY;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/* unregister interest in capacity changes */
2N/Aint
2N/Arcm_unregister_capacity(rcm_handle_t *hd, char *rsrcname, uint_t flag)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_CAPACITY;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/*
2N/A * Register to receive events. This requires a module to exist in module
2N/A * directory. It should be called prior to using a new resource.
2N/A */
2N/A/* ARGSUSED */
2N/Aint
2N/Arcm_register_event(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_EVENT;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/* unregister interest in events */
2N/Aint
2N/Arcm_unregister_event(rcm_handle_t *hd, char *rsrcname, uint_t flag)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_EVENT;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/*
2N/A * Register interest in a resource. This requires a module to exist in module
2N/A * directory. It should be called prior to using a new resource.
2N/A *
2N/A * Registration may be denied if it is presently locked by a DR operation.
2N/A */
2N/A/* ARGSUSED */
2N/Aint
2N/Arcm_register_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag,
2N/A rcm_info_t **infop)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_DR;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_REGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/* unregister interest in rsrcname */
2N/Aint
2N/Arcm_unregister_interest(rcm_handle_t *hd, char *rsrcname, uint_t flag)
2N/A{
2N/A char *rsrcnames[2];
2N/A
2N/A if (flag & ~RCM_REGISTER_MASK) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A flag |= RCM_REGISTER_DR;
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A return (rcm_common(CMD_UNREGISTER, hd, rsrcnames, flag, NULL, NULL));
2N/A}
2N/A
2N/A/* get the current state of a resource */
2N/Aint
2N/Arcm_get_rsrcstate(rcm_handle_t *hd, char *rsrcname, int *statep)
2N/A{
2N/A int result;
2N/A int flag = 0;
2N/A rcm_info_t *infop = NULL;
2N/A rcm_info_tuple_t *tuple = NULL;
2N/A char *rsrcnames[2];
2N/A
2N/A if (statep == NULL) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A rsrcnames[0] = rsrcname;
2N/A rsrcnames[1] = NULL;
2N/A
2N/A result = rcm_common(CMD_GETSTATE, hd, rsrcnames, flag, NULL, &infop);
2N/A
2N/A /*
2N/A * A successful result implies the presence of exactly one RCM info
2N/A * tuple containing the state of this resource (a combination of each
2N/A * client's resources). If that's not true, change the result to
2N/A * RCM_FAILURE.
2N/A */
2N/A if (result == RCM_SUCCESS) {
2N/A if ((infop == NULL) ||
2N/A ((tuple = rcm_info_next(infop, NULL)) == NULL) ||
2N/A (rcm_info_next(infop, tuple) != NULL)) {
2N/A result = RCM_FAILURE;
2N/A } else if (infop && tuple) {
2N/A *statep = rcm_info_state(tuple);
2N/A }
2N/A }
2N/A
2N/A if (infop)
2N/A rcm_free_info(infop);
2N/A
2N/A return (result);
2N/A}
2N/A
2N/A/*
2N/A * RCM helper functions exposed to librcm callers.
2N/A */
2N/A
2N/A/* Free linked list of registration info */
2N/Avoid
2N/Arcm_free_info(rcm_info_t *info)
2N/A{
2N/A while (info) {
2N/A rcm_info_t *tmp = info->next;
2N/A
2N/A if (info->info)
2N/A nvlist_free(info->info);
2N/A free(info);
2N/A
2N/A info = tmp;
2N/A }
2N/A}
2N/A
2N/A/* return the next tuple in the info structure */
2N/Arcm_info_tuple_t *
2N/Arcm_info_next(rcm_info_t *info, rcm_info_tuple_t *tuple)
2N/A{
2N/A if (info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (tuple == NULL) {
2N/A return ((rcm_info_tuple_t *)info);
2N/A }
2N/A return ((rcm_info_tuple_t *)tuple->next);
2N/A}
2N/A
2N/A/* return resource name */
2N/Aconst char *
2N/Arcm_info_rsrc(rcm_info_tuple_t *tuple)
2N/A{
2N/A char *rsrcname = NULL;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_string(tuple->info, RCM_RSRCNAME, &rsrcname))
2N/A return (NULL);
2N/A
2N/A return (rsrcname);
2N/A}
2N/A
2N/Aconst char *
2N/Arcm_info_info(rcm_info_tuple_t *tuple)
2N/A{
2N/A char *info = NULL;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_INFO, &info))
2N/A return (NULL);
2N/A
2N/A return (info);
2N/A}
2N/A
2N/Aconst char *
2N/Arcm_info_error(rcm_info_tuple_t *tuple)
2N/A{
2N/A char *errstr = NULL;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_ERROR,
2N/A &errstr))
2N/A return (NULL);
2N/A
2N/A return (errstr);
2N/A}
2N/A
2N/A/* return info string in the tuple */
2N/Aconst char *
2N/Arcm_info_modname(rcm_info_tuple_t *tuple)
2N/A{
2N/A char *modname = NULL;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_string(tuple->info, RCM_CLIENT_MODNAME,
2N/A &modname))
2N/A return (NULL);
2N/A
2N/A return (modname);
2N/A}
2N/A
2N/A/* return client pid in the tuple */
2N/Apid_t
2N/Arcm_info_pid(rcm_info_tuple_t *tuple)
2N/A{
2N/A uint64_t pid64 = (uint64_t)0;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return ((pid_t)0);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_uint64(tuple->info, RCM_CLIENT_ID, &pid64))
2N/A return ((pid_t)0);
2N/A
2N/A return ((pid_t)pid64);
2N/A}
2N/A
2N/A/* return client state in the tuple */
2N/Aint
2N/Arcm_info_state(rcm_info_tuple_t *tuple)
2N/A{
2N/A int state;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (RCM_STATE_UNKNOWN);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_int32(tuple->info, RCM_RSRCSTATE, &state))
2N/A return (RCM_STATE_UNKNOWN);
2N/A
2N/A return (state);
2N/A}
2N/A
2N/A/* return the generic properties in the tuple */
2N/Anvlist_t *
2N/Arcm_info_properties(rcm_info_tuple_t *tuple)
2N/A{
2N/A char *buf;
2N/A uint_t buflen;
2N/A nvlist_t *nvl;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (NULL);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_byte_array(tuple->info, RCM_CLIENT_PROPERTIES,
2N/A (uchar_t **)&buf, &buflen))
2N/A return (NULL);
2N/A
2N/A if (errno = nvlist_unpack(buf, buflen, &nvl, 0)) {
2N/A free(buf);
2N/A return (NULL);
2N/A }
2N/A
2N/A return (nvl);
2N/A}
2N/A
2N/A/*
2N/A * return operation sequence number
2N/A *
2N/A * This is private. Called by rcmctl only for testing purposes.
2N/A */
2N/Aint
2N/Arcm_info_seqnum(rcm_info_tuple_t *tuple)
2N/A{
2N/A int seqnum;
2N/A
2N/A if (tuple == NULL || tuple->info == NULL) {
2N/A errno = EINVAL;
2N/A return (-1);
2N/A }
2N/A
2N/A if (errno = nvlist_lookup_int32(tuple->info, RCM_SEQ_NUM, &seqnum))
2N/A return (-1);
2N/A
2N/A return (seqnum);
2N/A}
2N/A
2N/A
2N/A/*
2N/A * The following interfaces are PRIVATE to the RCM framework. They are not
2N/A * declared static because they are called by rcm_daemon.
2N/A */
2N/A
2N/A/*
2N/A * Invoke shell to execute command in MT safe manner.
2N/A * Returns wait status or -1 on error.
2N/A */
2N/Aint
2N/Arcm_exec_cmd(char *cmd)
2N/A{
2N/A pid_t pid;
2N/A int status, w;
2N/A char *argvec[] = {"sh", "-c", NULL, NULL};
2N/A
2N/A argvec[2] = cmd;
2N/A if ((pid = fork1()) == 0) {
2N/A (void) execv("/bin/sh", argvec);
2N/A _exit(127);
2N/A } else if (pid == -1) {
2N/A return (-1);
2N/A }
2N/A
2N/A do {
2N/A w = waitpid(pid, &status, 0);
2N/A } while (w == -1 && errno == EINTR);
2N/A
2N/A return ((w == -1) ? w : status);
2N/A}
2N/A
2N/A/* Append info at the very end */
2N/Aint
2N/Arcm_append_info(rcm_info_t **head, rcm_info_t *info)
2N/A{
2N/A rcm_info_t *tuple;
2N/A
2N/A if (head == NULL) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if ((tuple = *head) == NULL) {
2N/A *head = info;
2N/A return (RCM_SUCCESS);
2N/A }
2N/A
2N/A while (tuple->next) {
2N/A tuple = tuple->next;
2N/A }
2N/A tuple->next = info;
2N/A return (RCM_SUCCESS);
2N/A}
2N/A
2N/A/* get rcm module and rcm script directory names */
2N/A
2N/A#define N_MODULE_DIR 3 /* search 3 directories for modules */
2N/A#define MODULE_DIR_HW "/usr/platform/%s/lib/rcm/modules/"
2N/A#define MODULE_DIR_GEN "/usr/lib/rcm/modules/"
2N/A
2N/A#define N_SCRIPT_DIR 4 /* search 4 directories for scripts */
2N/A#define SCRIPT_DIR_HW "/usr/platform/%s/lib/rcm/scripts/"
2N/A#define SCRIPT_DIR_GEN "/usr/lib/rcm/scripts/"
2N/A#define SCRIPT_DIR_ETC "/etc/rcm/scripts/"
2N/A
2N/A
2N/Achar *
2N/Arcm_module_dir(uint_t dirnum)
2N/A{
2N/A if (dirnum < N_MODULE_DIR)
2N/A return (rcm_dir(dirnum, NULL));
2N/A else
2N/A return (NULL);
2N/A}
2N/A
2N/Achar *
2N/Arcm_script_dir(uint_t dirnum)
2N/A{
2N/A if (dirnum < N_SCRIPT_DIR)
2N/A return (rcm_dir(dirnum + N_MODULE_DIR, NULL));
2N/A else
2N/A return (NULL);
2N/A}
2N/A
2N/Achar *
2N/Arcm_dir(uint_t dirnum, int *rcm_script)
2N/A{
2N/A static char dir_name[N_MODULE_DIR + N_SCRIPT_DIR][MAXPATHLEN];
2N/A
2N/A char infobuf[MAXPATHLEN];
2N/A
2N/A if (dirnum >= (N_MODULE_DIR + N_SCRIPT_DIR))
2N/A return (NULL);
2N/A
2N/A if (dir_name[0][0] == '\0') {
2N/A /*
2N/A * construct the module directory names
2N/A */
2N/A if (sysinfo(SI_PLATFORM, infobuf, MAXPATHLEN) == -1) {
2N/A dprintf((stderr, "sysinfo %s\n", strerror(errno)));
2N/A return (NULL);
2N/A } else {
2N/A if (snprintf(dir_name[0], MAXPATHLEN, MODULE_DIR_HW,
2N/A infobuf) >= MAXPATHLEN ||
2N/A snprintf(dir_name[N_MODULE_DIR + 1], MAXPATHLEN,
2N/A SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
2N/A dprintf((stderr,
2N/A "invalid module or script directory for "
2N/A "platform %s\n", infobuf));
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A if (sysinfo(SI_MACHINE, infobuf, MAXPATHLEN) == -1) {
2N/A dprintf((stderr, "sysinfo %s\n", strerror(errno)));
2N/A return (NULL);
2N/A } else {
2N/A if (snprintf(dir_name[1], MAXPATHLEN, MODULE_DIR_HW,
2N/A infobuf) >= MAXPATHLEN ||
2N/A snprintf(dir_name[N_MODULE_DIR + 2], MAXPATHLEN,
2N/A SCRIPT_DIR_HW, infobuf) >= MAXPATHLEN) {
2N/A dprintf((stderr,
2N/A "invalid module or script directory for "
2N/A "machine type %s\n", infobuf));
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A if (strlcpy(dir_name[2], MODULE_DIR_GEN, MAXPATHLEN) >=
2N/A MAXPATHLEN ||
2N/A strlcpy(dir_name[N_MODULE_DIR + 3], SCRIPT_DIR_GEN,
2N/A MAXPATHLEN) >= MAXPATHLEN ||
2N/A strlcpy(dir_name[N_MODULE_DIR + 0], SCRIPT_DIR_ETC,
2N/A MAXPATHLEN) >= MAXPATHLEN) {
2N/A dprintf((stderr,
2N/A "invalid module or script generic directory\n"));
2N/A return (NULL);
2N/A }
2N/A }
2N/A
2N/A if (rcm_script)
2N/A *rcm_script = (dirnum < N_MODULE_DIR) ? 0 : 1;
2N/A
2N/A return (dir_name[dirnum]);
2N/A}
2N/A
2N/A/*
2N/A * Find the directory where the script is located.
2N/A * If the script is found return a pointer to the directory where the
2N/A * script was found otherwise return NULL.
2N/A */
2N/Achar *
2N/Arcm_get_script_dir(char *script_name)
2N/A{
2N/A uint_t i;
2N/A char *dir_name;
2N/A char path[MAXPATHLEN];
2N/A struct stat stats;
2N/A
2N/A for (i = 0; (dir_name = rcm_script_dir(i)) != NULL; i++) {
2N/A if (snprintf(path, MAXPATHLEN, "%s%s", dir_name, script_name)
2N/A >= MAXPATHLEN) {
2N/A dprintf((stderr, "invalid script %s skipped\n",
2N/A script_name));
2N/A continue;
2N/A }
2N/A if (stat(path, &stats) == 0)
2N/A return (dir_name);
2N/A }
2N/A
2N/A return (NULL);
2N/A}
2N/A
2N/A/*
2N/A * Returns 1 if the filename is an rcm script.
2N/A * Returns 0 if the filename is an rcm module.
2N/A */
2N/Aint
2N/Arcm_is_script(char *filename)
2N/A{
2N/A char *tmp;
2N/A
2N/A if (((tmp = strstr(filename, RCM_MODULE_SUFFIX)) != NULL) &&
2N/A (tmp[strlen(RCM_MODULE_SUFFIX)] == '\0'))
2N/A return (0);
2N/A else
2N/A return (1);
2N/A}
2N/A
2N/A/* Locate the module and call dlopen */
2N/Avoid *
2N/Arcm_module_open(char *modname)
2N/A{
2N/A unsigned i;
2N/A char *dir_name;
2N/A void *dlhandle = NULL;
2N/A char modpath[MAXPATHLEN];
2N/A
2N/A#ifdef DEBUG
2N/A struct stat sbuf;
2N/A#endif
2N/A
2N/A /*
2N/A * dlopen the module
2N/A */
2N/A for (i = 0; (dir_name = rcm_module_dir(i)) != NULL; i++) {
2N/A if (snprintf(modpath, MAXPATHLEN, "%s%s", dir_name, modname)
2N/A >= MAXPATHLEN) {
2N/A dprintf((stderr, "invalid module %s skipped\n",
2N/A modname));
2N/A continue;
2N/A }
2N/A
2N/A if ((dlhandle = dlopen(modpath, RTLD_LAZY)) != NULL) {
2N/A return (dlhandle);
2N/A }
2N/A
2N/A dprintf((stderr, "failure (dlopen=%s)\n", dlerror()));
2N/A#ifdef DEBUG
2N/A if (stat(modpath, &sbuf) == 0) {
2N/A (void) fprintf(stderr, "%s is not a valid module\n",
2N/A modpath);
2N/A }
2N/A#endif
2N/A }
2N/A
2N/A dprintf((stderr, "module %s not found\n", modname));
2N/A return (NULL);
2N/A}
2N/A
2N/A/* dlclose module */
2N/Avoid
2N/Arcm_module_close(void *dlhandle)
2N/A{
2N/A if (dlclose(dlhandle) == 0)
2N/A return;
2N/A
2N/A dprintf((stderr, "dlclose: %s\n", dlerror()));
2N/A}
2N/A
2N/A
2N/A/*
2N/A * stub implementation of rcm_log_message allows dlopen of rcm modules
2N/A * to proceed in absence of rcm_daemon.
2N/A *
2N/A * This definition is interposed by the definition in rcm_daemon because of the
2N/A * default search order implemented by the linker and dlsym(). All RCM modules
2N/A * will see the daemon version when loaded by the rcm_daemon.
2N/A */
2N/A/* ARGSUSED */
2N/Avoid
2N/Arcm_log_message(int level, char *message, ...)
2N/A{
2N/A dprintf((stderr, "rcm_log_message stub\n"));
2N/A}
2N/A
2N/A/*
2N/A * Helper functions
2N/A */
2N/A
2N/A/*
2N/A * Common routine for all rcm calls which require daemon processing
2N/A */
2N/Astatic int
2N/Arcm_common(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag, void *arg,
2N/A rcm_info_t **infop)
2N/A{
2N/A int i;
2N/A
2N/A if (hd == NULL) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if (getuid() != 0) {
2N/A errno = EPERM;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if ((flag & (RCM_DR_OPERATION | RCM_MOD_INFO)) == 0) {
2N/A if ((rsrcnames == NULL) || (rsrcnames[0] == NULL)) {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A for (i = 0; rsrcnames[i] != NULL; i++) {
2N/A if (*rsrcnames[i] == '\0') {
2N/A errno = EINVAL;
2N/A return (RCM_FAILURE);
2N/A }
2N/A }
2N/A }
2N/A
2N/A /*
2N/A * Check if handle is allocated by rcm_daemon. If so, this call came
2N/A * from an RCM module, so we make a direct call into rcm_daemon.
2N/A */
2N/A if (hd->lrcm_ops != NULL) {
2N/A return (rcm_direct_call(cmd, hd, rsrcnames, flag, arg, infop));
2N/A }
2N/A
2N/A /*
2N/A * When not called from a RCM module (i.e. no recursion), zero the
2N/A * pointer just in case caller did not do so. For recursive calls,
2N/A * we want to append rcm_info_t after infop; zero it may cause
2N/A * memory leaks.
2N/A */
2N/A if (infop) {
2N/A *infop = NULL;
2N/A }
2N/A
2N/A /*
2N/A * Now call into the daemon.
2N/A */
2N/A return (rcm_daemon_call(cmd, hd, rsrcnames, flag, arg, infop));
2N/A}
2N/A
2N/A/*
2N/A * Caller is an RCM module, call directly into rcm_daemon.
2N/A */
2N/Astatic int
2N/Arcm_direct_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A void *arg, rcm_info_t **infop)
2N/A{
2N/A int error;
2N/A
2N/A librcm_ops_t *ops = (librcm_ops_t *)hd->lrcm_ops;
2N/A switch (cmd) {
2N/A case CMD_GETINFO:
2N/A error = ops->librcm_getinfo(rsrcnames, flag, hd->seq_num,
2N/A infop);
2N/A break;
2N/A
2N/A case CMD_OFFLINE:
2N/A error = ops->librcm_offline(rsrcnames, hd->pid, flag,
2N/A hd->seq_num, infop);
2N/A break;
2N/A
2N/A case CMD_ONLINE:
2N/A error = ops->librcm_online(rsrcnames, hd->pid, flag,
2N/A hd->seq_num, infop);
2N/A break;
2N/A
2N/A case CMD_REMOVE:
2N/A error = ops->librcm_remove(rsrcnames, hd->pid, flag,
2N/A hd->seq_num, infop);
2N/A break;
2N/A
2N/A case CMD_SUSPEND:
2N/A error = ops->librcm_suspend(rsrcnames, hd->pid, flag,
2N/A hd->seq_num, (timespec_t *)arg, infop);
2N/A break;
2N/A
2N/A case CMD_RESUME:
2N/A error = ops->librcm_resume(rsrcnames, hd->pid, flag,
2N/A hd->seq_num, infop);
2N/A break;
2N/A
2N/A case CMD_REGISTER:
2N/A error = ops->librcm_regis(hd->modname, rsrcnames[0], hd->pid,
2N/A flag, infop);
2N/A break;
2N/A
2N/A case CMD_UNREGISTER:
2N/A error = ops->librcm_unregis(hd->modname, rsrcnames[0], hd->pid,
2N/A flag);
2N/A break;
2N/A
2N/A case CMD_REQUEST_CHANGE:
2N/A error = ops->librcm_request_change(rsrcnames[0], hd->pid, flag,
2N/A hd->seq_num, (nvlist_t *)arg, infop);
2N/A break;
2N/A
2N/A case CMD_NOTIFY_CHANGE:
2N/A error = ops->librcm_notify_change(rsrcnames[0], hd->pid, flag,
2N/A hd->seq_num, (nvlist_t *)arg, infop);
2N/A break;
2N/A
2N/A case CMD_EVENT:
2N/A error = ops->librcm_notify_event(rsrcnames[0], hd->pid, flag,
2N/A hd->seq_num, (nvlist_t *)arg, infop);
2N/A break;
2N/A
2N/A case CMD_GETSTATE:
2N/A error = ops->librcm_getstate(rsrcnames[0], hd->pid, infop);
2N/A break;
2N/A
2N/A default:
2N/A dprintf((stderr, "invalid command: %d\n", cmd));
2N/A error = EFAULT;
2N/A }
2N/A
2N/A if (error > 0) {
2N/A errno = error;
2N/A error = RCM_FAILURE;
2N/A }
2N/A return (error);
2N/A}
2N/A
2N/A/*
2N/A * Call into rcm_daemon door to process the request
2N/A */
2N/Astatic int
2N/Arcm_daemon_call(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A void *arg, rcm_info_t **infop)
2N/A{
2N/A int errno_found;
2N/A int daemon_errno = 0;
2N/A int error = RCM_SUCCESS;
2N/A int delay = 300;
2N/A int maxdelay = 10000; /* 10 seconds */
2N/A char *nvl_packed = NULL;
2N/A size_t nvl_size = 0;
2N/A nvlist_t *ret = NULL;
2N/A nvpair_t *nvp;
2N/A size_t rsize = 0;
2N/A rcm_info_t *info = NULL;
2N/A
2N/A errno = 0;
2N/A
2N/A /*
2N/A * Decide whether to start the daemon
2N/A */
2N/A switch (cmd) {
2N/A case CMD_GETINFO:
2N/A case CMD_OFFLINE:
2N/A case CMD_ONLINE:
2N/A case CMD_REMOVE:
2N/A case CMD_SUSPEND:
2N/A case CMD_RESUME:
2N/A case CMD_REGISTER:
2N/A case CMD_UNREGISTER:
2N/A case CMD_EVENT:
2N/A case CMD_REQUEST_CHANGE:
2N/A case CMD_NOTIFY_CHANGE:
2N/A case CMD_GETSTATE:
2N/A break;
2N/A
2N/A default:
2N/A errno = EFAULT;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A if (rcm_daemon_is_alive() != 1) {
2N/A dprintf((stderr, "failed to start rcm_daemon\n"));
2N/A errno = EFAULT;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A /*
2N/A * Generate a packed nvlist for the request
2N/A */
2N/A if (rcm_generate_nvlist(cmd, hd, rsrcnames, flag, arg, &nvl_packed,
2N/A &nvl_size) < 0) {
2N/A dprintf((stderr, "error in nvlist generation\n"));
2N/A errno = EFAULT;
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A /*
2N/A * Make the door call and get a return event. We go into a retry loop
2N/A * when RCM_ET_EAGAIN is returned.
2N/A */
2N/Aretry:
2N/A if (get_event_service(RCM_SERVICE_DOOR, (void *)nvl_packed, nvl_size,
2N/A (void **)&ret, &rsize) < 0) {
2N/A dprintf((stderr, "rcm_daemon call failed: %s\n",
2N/A strerror(errno)));
2N/A free(nvl_packed);
2N/A return (RCM_FAILURE);
2N/A }
2N/A
2N/A assert(ret != NULL);
2N/A
2N/A /*
2N/A * nvlist_lookup_* routines don't work because the returned nvlist
2N/A * was nvlist_alloc'ed without the NV_UNIQUE_NAME flag. Implement
2N/A * a sequential search manually, which is fine since there is only
2N/A * one RCM_RESULT value in the nvlist.
2N/A */
2N/A errno_found = 0;
2N/A nvp = NULL;
2N/A while (nvp = nvlist_next_nvpair(ret, nvp)) {
2N/A if (strcmp(nvpair_name(nvp), RCM_RESULT) == 0) {
2N/A if (errno = nvpair_value_int32(nvp, &daemon_errno)) {
2N/A error = RCM_FAILURE;
2N/A goto out;
2N/A }
2N/A errno_found++;
2N/A break;
2N/A }
2N/A }
2N/A if (errno_found == 0) {
2N/A errno = EFAULT;
2N/A error = RCM_FAILURE;
2N/A goto out;
2N/A }
2N/A
2N/A if (daemon_errno == EAGAIN) {
2N/A /*
2N/A * Wait and retry
2N/A */
2N/A dprintf((stderr, "retry door_call\n"));
2N/A
2N/A if (delay > maxdelay) {
2N/A errno = EAGAIN;
2N/A error = RCM_FAILURE;
2N/A goto out;
2N/A }
2N/A
2N/A (void) poll(NULL, 0, delay);
2N/A delay *= 2; /* exponential back off */
2N/A nvlist_free(ret);
2N/A goto retry;
2N/A }
2N/A
2N/A /*
2N/A * The door call succeeded. Now extract info from returned event.
2N/A */
2N/A if (extract_info(ret, &info) != 0) {
2N/A dprintf((stderr, "error in extracting event data\n"));
2N/A errno = EFAULT;
2N/A error = RCM_FAILURE;
2N/A goto out;
2N/A }
2N/A
2N/A if (infop)
2N/A *infop = info;
2N/A else
2N/A rcm_free_info(info);
2N/A
2N/A if (daemon_errno) {
2N/A if (daemon_errno > 0) {
2N/A errno = daemon_errno;
2N/A error = RCM_FAILURE;
2N/A } else {
2N/A error = daemon_errno;
2N/A }
2N/A }
2N/A
2N/Aout:
2N/A if (nvl_packed)
2N/A free(nvl_packed);
2N/A if (ret)
2N/A nvlist_free(ret);
2N/A dprintf((stderr, "daemon call is done. error = %d, errno = %s\n", error,
2N/A strerror(errno)));
2N/A return (error);
2N/A}
2N/A
2N/A/*
2N/A * Extract registration info from event data.
2N/A * Return 0 on success and -1 on failure.
2N/A */
2N/Astatic int
2N/Aextract_info(nvlist_t *nvl, rcm_info_t **infop)
2N/A{
2N/A rcm_info_t *info = NULL;
2N/A rcm_info_t *prev = NULL;
2N/A rcm_info_t *tmp = NULL;
2N/A char *buf;
2N/A uint_t buflen;
2N/A nvpair_t *nvp = NULL;
2N/A
2N/A while (nvp = nvlist_next_nvpair(nvl, nvp)) {
2N/A
2N/A buf = NULL;
2N/A buflen = 0;
2N/A
2N/A if (strcmp(nvpair_name(nvp), RCM_RESULT_INFO) != 0)
2N/A continue;
2N/A
2N/A if ((tmp = calloc(1, sizeof (*tmp))) == NULL) {
2N/A dprintf((stderr, "out of memory\n"));
2N/A goto fail;
2N/A }
2N/A
2N/A if (errno = nvpair_value_byte_array(nvp, (uchar_t **)&buf,
2N/A &buflen)) {
2N/A free(tmp);
2N/A dprintf((stderr, "failed (nvpair_value=%s)\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A if (errno = nvlist_unpack(buf, buflen, &(tmp->info), 0)) {
2N/A free(tmp);
2N/A dprintf((stderr, "failed (nvlist_unpack=%s)\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A
2N/A if (info == NULL) {
2N/A prev = info = tmp;
2N/A } else {
2N/A prev->next = tmp;
2N/A prev = tmp;
2N/A }
2N/A }
2N/A
2N/A *infop = info;
2N/A return (0);
2N/A
2N/Afail:
2N/A rcm_free_info(info);
2N/A *infop = NULL;
2N/A return (-1);
2N/A}
2N/A
2N/A/* Generate a packed nvlist for communicating with RCM daemon */
2N/Astatic int
2N/Arcm_generate_nvlist(int cmd, rcm_handle_t *hd, char **rsrcnames, uint_t flag,
2N/A void *arg, char **nvl_packed, size_t *nvl_size)
2N/A{
2N/A int nrsrcnames;
2N/A char *buf = NULL;
2N/A size_t buflen = 0;
2N/A nvlist_t *nvl = NULL;
2N/A
2N/A assert((nvl_packed != NULL) && (nvl_size != NULL));
2N/A
2N/A *nvl_size = 0;
2N/A *nvl_packed = NULL;
2N/A
2N/A /* Allocate an empty nvlist */
2N/A if ((errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) > 0) {
2N/A dprintf((stderr, "failed (nvlist_alloc=%s).\n",
2N/A strerror(errno)));
2N/A return (-1);
2N/A }
2N/A
2N/A /* Stuff in all the arguments for the daemon call */
2N/A if (nvlist_add_int32(nvl, RCM_CMD, cmd) != 0) {
2N/A dprintf((stderr, "failed (nvlist_add(CMD)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A if (rsrcnames) {
2N/A nrsrcnames = 0;
2N/A while (rsrcnames[nrsrcnames] != NULL)
2N/A nrsrcnames++;
2N/A if (nvlist_add_string_array(nvl, RCM_RSRCNAMES, rsrcnames,
2N/A nrsrcnames) != 0) {
2N/A dprintf((stderr, "failed (nvlist_add(RSRCNAMES)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (hd->modname) {
2N/A if (nvlist_add_string(nvl, RCM_CLIENT_MODNAME, hd->modname)
2N/A != 0) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_add(CLIENT_MODNAME)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (hd->pid) {
2N/A if (nvlist_add_uint64(nvl, RCM_CLIENT_ID, hd->pid) != 0) {
2N/A dprintf((stderr, "failed (nvlist_add(CLIENT_ID)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (flag) {
2N/A if (nvlist_add_uint32(nvl, RCM_REQUEST_FLAG, flag) != 0) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_add(REQUEST_FLAG)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (arg && cmd == CMD_SUSPEND) {
2N/A if (nvlist_add_byte_array(nvl, RCM_SUSPEND_INTERVAL,
2N/A (uchar_t *)arg, sizeof (timespec_t)) != 0) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_add(SUSPEND_INTERVAL)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (arg &&
2N/A ((cmd == CMD_REQUEST_CHANGE) || (cmd == CMD_NOTIFY_CHANGE))) {
2N/A if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
2N/A 0)) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A if (nvlist_add_byte_array(nvl, RCM_CHANGE_DATA, (uchar_t *)buf,
2N/A buflen) != 0) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_add(CHANGE_DATA)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A if (arg && cmd == CMD_EVENT) {
2N/A if (errno = nvlist_pack(arg, &buf, &buflen, NV_ENCODE_NATIVE,
2N/A 0)) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_pack(CHANGE_DATA)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A if (nvlist_add_byte_array(nvl, RCM_EVENT_DATA, (uchar_t *)buf,
2N/A buflen) != 0) {
2N/A dprintf((stderr,
2N/A "failed (nvlist_add(EVENT_DATA)=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A }
2N/A
2N/A /* Pack the nvlist */
2N/A if (errno = nvlist_pack(nvl, nvl_packed, nvl_size, NV_ENCODE_NATIVE,
2N/A 0)) {
2N/A dprintf((stderr, "failed (nvlist_pack=%s).\n",
2N/A strerror(errno)));
2N/A goto fail;
2N/A }
2N/A
2N/A /* If an argument was packed intermediately, free the buffer */
2N/A if (buf)
2N/A free(buf);
2N/A
2N/A /* Free the unpacked version of the nvlist and return the packed list */
2N/A nvlist_free(nvl);
2N/A return (0);
2N/A
2N/Afail:
2N/A if (buf)
2N/A free(buf);
2N/A if (nvl)
2N/A nvlist_free(nvl);
2N/A if (*nvl_packed)
2N/A free(*nvl_packed);
2N/A *nvl_packed = NULL;
2N/A *nvl_size = 0;
2N/A return (-1);
2N/A}
2N/A
2N/A/* check if rcm_daemon is up and running */
2N/Astatic int
2N/Arcm_daemon_is_alive()
2N/A{
2N/A int lasttry;
2N/A struct stat st;
2N/A nvlist_t *nvl;
2N/A char *buf = NULL;
2N/A size_t buflen = 0;
2N/A int delay = 300;
2N/A const int maxdelay = 10000; /* 10 sec */
2N/A
2N/A /* generate a packed nvlist for the door knocking */
2N/A if (errno = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) {
2N/A dprintf((stderr, "nvlist_alloc failed: %s\n", strerror(errno)));
2N/A return (0);
2N/A }
2N/A if (errno = nvlist_add_int32(nvl, RCM_CMD, CMD_KNOCK)) {
2N/A dprintf((stderr, "nvlist_add failed: %s\n", strerror(errno)));
2N/A nvlist_free(nvl);
2N/A return (0);
2N/A }
2N/A if (errno = nvlist_pack(nvl, &buf, &buflen, NV_ENCODE_NATIVE, 0)) {
2N/A dprintf((stderr, "nvlist_pack failed: %s\n", strerror(errno)));
2N/A nvlist_free(nvl);
2N/A return (0);
2N/A }
2N/A nvlist_free(nvl);
2N/A
2N/A /*
2N/A * check the door and knock on it
2N/A */
2N/A if ((stat(RCM_SERVICE_DOOR, &st) == 0) &&
2N/A (get_event_service(RCM_SERVICE_DOOR, (void *)buf, buflen, NULL,
2N/A NULL) == 0)) {
2N/A free(buf);
2N/A return (1); /* daemon is alive */
2N/A }
2N/A
2N/A /*
2N/A * Attempt to start the daemon.
2N/A * If caller has SIGCHLD set to SIG_IGN or its SA_NOCLDWAIT
2N/A * flag set, waitpid(2) (hence rcm_exec_cmd) will fail.
2N/A * get_event_service will determine if the rcm_daemon started.
2N/A */
2N/A dprintf((stderr, "exec: %s\n", RCM_DAEMON_START));
2N/A (void) rcm_exec_cmd(RCM_DAEMON_START);
2N/A
2N/A /*
2N/A * Wait for daemon to respond, timeout at 10 sec
2N/A */
2N/A while (((lasttry = get_event_service(RCM_SERVICE_DOOR, (void *)buf,
2N/A buflen, NULL, NULL)) != 0) &&
2N/A ((errno == EBADF) || (errno == ESRCH))) {
2N/A if (delay > maxdelay) {
2N/A break;
2N/A }
2N/A (void) poll(NULL, 0, delay);
2N/A delay *= 2;
2N/A }
2N/A
2N/A free(buf);
2N/A if (lasttry == 0)
2N/A return (1);
2N/A return (0);
2N/A}
2N/A
2N/A/*
2N/A * Check permission.
2N/A *
2N/A * The policy is root only for now. Need to relax this when interface level
2N/A * is raised.
2N/A */
2N/Astatic int
2N/Arcm_check_permission(void)
2N/A{
2N/A return (getuid() == 0);
2N/A}
2N/A
2N/A/*
2N/A * Project private function - for use by RCM MSTC tests
2N/A *
2N/A * Get the client name (rcm module name or script name) corresponding to
2N/A * the given rcm handle.
2N/A */
2N/Aconst char *
2N/Arcm_get_client_name(rcm_handle_t *hd)
2N/A{
2N/A return (hd->modname);
2N/A}