OpenSolaris_b135/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.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#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;
if (info->info)
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);
if (ret)
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);
if (nvl)
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);
}