OpenSolaris_b135/cmd/rcm_daemon/common/mpxio_rcm.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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* RCM module supporting multiplexed I/O controllers (MPxIO).
*/
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <assert.h>
#include <syslog.h>
#include <string.h>
#include <synch.h>
#include <libintl.h>
#include <locale.h>
#include <ctype.h>
#include <errno.h>
#include <libdevinfo.h>
#include <sys/types.h>
#include "rcm_module.h"
#define MPXIO_PROP_NAME "mpxio-component"
#define MPXIO_PROP_CLIENT "client"
#define CMD_GETINFO 0
#define CMD_OFFLINE 1
#define CMD_ONLINE 2
#define CMD_REMOVE 3
#define CACHE_NEW 0
#define CACHE_REFERENCED 1
#define CACHE_STALE 2
#define MPXIO_MSG_CACHEFAIL gettext("Internal analysis failure.")
#define MPXIO_MSG_LASTPATH gettext("Last path to busy resources.")
#define MPXIO_MSG_USAGE gettext("SCSI Multipathing PHCI (%s)")
#define MPXIO_MSG_USAGEUNKNOWN gettext("SCSI Multipathing PHCI (<unknown>)")
typedef struct {
char *path;
di_path_state_t state;
} phci_t;
typedef struct phci_list {
phci_t phci;
int referenced;
struct phci_list *next;
} phci_list_t;
typedef struct group {
int offline;
int nphcis;
int nclients;
phci_t *phcis;
char **clients;
struct group *next;
} group_t;
static int mpxio_register(rcm_handle_t *);
static int mpxio_unregister(rcm_handle_t *);
static int mpxio_getinfo(rcm_handle_t *, char *, id_t, uint_t, char **, char **,
nvlist_t *, rcm_info_t **);
static int mpxio_suspend(rcm_handle_t *, char *, id_t, timespec_t *, uint_t,
char **, rcm_info_t **);
static int mpxio_resume(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int mpxio_offline(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int mpxio_online(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int mpxio_remove(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int get_nclients(di_node_t, void *);
static int build_groups(di_node_t, void *);
static void refresh_regs(rcm_handle_t *);
static int get_affected_clients(rcm_handle_t *, char *, int, int, char ***);
static int detect_client_change(rcm_handle_t *, int, int, group_t *, char *);
static int merge_clients(int *, char ***, group_t *);
static phci_list_t *lookup_phci(char *);
static int is_client(di_node_t);
static char *get_rsrcname(di_node_t);
static char *s_state(di_path_state_t);
static int compare_phci(const void *, const void *);
static void free_grouplist();
static void free_group(group_t *);
static void free_clients(int, char **);
static void free_phcis(int, phci_t *);
static struct rcm_mod_ops mpxio_ops =
{
RCM_MOD_OPS_VERSION,
mpxio_register,
mpxio_unregister,
mpxio_getinfo,
mpxio_suspend,
mpxio_resume,
mpxio_offline,
mpxio_online,
mpxio_remove,
NULL,
NULL,
NULL
};
static group_t *group_list;
static phci_list_t *reg_list;
static mutex_t mpxio_lock;
extern int errno;
/*
* Return the mod-ops vector for initialization.
*/
struct rcm_mod_ops *
rcm_mod_init()
{
rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_init()\n");
return (&mpxio_ops);
}
/*
* Return name and version number for mod_info.
*/
const char *
rcm_mod_info()
{
rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_info()\n");
return (gettext("RCM MPxIO module 1.6"));
}
/*
* Destroy the cache and mutex lock when being unloaded.
*/
int
rcm_mod_fini()
{
phci_list_t *reg;
phci_list_t *next;
rcm_log_message(RCM_TRACE1, "MPXIO: rcm_mod_fini()\n");
/* Free the cache of MPxIO group information */
free_grouplist();
/* Free the cache of registrants */
reg = reg_list;
while (reg) {
next = reg->next;
free(reg->phci.path);
free(reg);
reg = next;
}
/* Destroy the mutex for locking the caches */
(void) mutex_destroy(&mpxio_lock);
return (RCM_SUCCESS);
}
/*
* During each register callback: totally rebuild the group list from a new
* libdevinfo snapshot, and then update the registrants.
*/
static int
mpxio_register(rcm_handle_t *hdl)
{
int nclients = 0;
di_node_t devroot;
rcm_log_message(RCM_TRACE1, "MPXIO: register()\n");
(void) mutex_lock(&mpxio_lock);
/* Destroy the previous group list */
free_grouplist();
/* Get a current libdevinfo snapshot */
if ((devroot = di_init("/", DINFOCPYALL | DINFOPATH)) == DI_NODE_NIL) {
rcm_log_message(RCM_ERROR,
"MPXIO: libdevinfo initialization failed (%s).\n",
strerror(errno));
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
/*
* First count the total number of clients. This'll be a useful
* upper bound when allocating client arrays within each group.
*/
(void) di_walk_node(devroot, DI_WALK_CLDFIRST, &nclients, get_nclients);
rcm_log_message(RCM_TRACE2, gettext("MPXIO: found %d clients.\n"),
nclients);
/*
* Then walk the libdevinfo snapshot, building up the new group list
* along the way. Pass in the total number of clients (from above) to
* assist in group construction.
*/
(void) di_walk_node(devroot, DI_WALK_CLDFIRST, &nclients, build_groups);
/* Now with a new group list constructed, refresh the registrants */
refresh_regs(hdl);
/* Free the libdevinfo snapshot */
di_fini(devroot);
(void) mutex_unlock(&mpxio_lock);
return (0);
}
/*
* Unregister all PHCIs and mark the whole registrants list as stale.
*/
static int
mpxio_unregister(rcm_handle_t *hdl)
{
phci_list_t *reg;
rcm_log_message(RCM_TRACE1, "MPXIO: unregister()\n");
(void) mutex_lock(&mpxio_lock);
for (reg = reg_list; reg != NULL; reg = reg->next) {
(void) rcm_unregister_interest(hdl, reg->phci.path, 0);
reg->referenced = CACHE_STALE;
}
(void) mutex_unlock(&mpxio_lock);
return (RCM_SUCCESS);
}
/*
* To return usage information, just lookup the PHCI in the cache and return
* a string identifying that it's a PHCI and describing its cached MPxIO state.
* Recurse with the cached list of disks if dependents are to be included.
*/
static int
mpxio_getinfo(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
char **infostr, char **errstr, nvlist_t *props, rcm_info_t **infop)
{
size_t len;
int rv = RCM_SUCCESS;
char *buf = NULL;
char **clients = NULL;
phci_list_t *reg;
char c;
rcm_log_message(RCM_TRACE1, "MPXIO: getinfo(%s)\n", rsrc);
*infostr = NULL;
*errstr = NULL;
(void) mutex_lock(&mpxio_lock);
if ((reg = lookup_phci(rsrc)) == NULL) {
*errstr = strdup(MPXIO_MSG_CACHEFAIL);
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
len = snprintf(&c, 1, MPXIO_MSG_USAGE, s_state(reg->phci.state));
buf = calloc(len + 1, sizeof (char));
if ((buf == NULL) || (snprintf(buf, len + 1, MPXIO_MSG_USAGE,
s_state(reg->phci.state)) > len + 1)) {
*infostr = strdup(MPXIO_MSG_USAGEUNKNOWN);
*errstr = strdup(gettext("Cannot construct usage string."));
(void) mutex_unlock(&mpxio_lock);
if (buf)
free(buf);
return (RCM_FAILURE);
}
*infostr = buf;
if (flags & RCM_INCLUDE_DEPENDENT) {
rcm_log_message(RCM_TRACE2, "MPXIO: getting clients\n");
if (get_affected_clients(hdl, rsrc, CMD_GETINFO, flags,
&clients) < 0) {
*errstr = strdup(gettext("Cannot lookup clients."));
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
if (clients) {
rv = rcm_get_info_list(hdl, clients, flags, infop);
free(clients);
} else {
rcm_log_message(RCM_TRACE2, "MPXIO: none found\n");
}
}
(void) mutex_unlock(&mpxio_lock);
return (rv);
}
/*
* Nothing is implemented for suspend operations.
*/
static int
mpxio_suspend(rcm_handle_t *hdl, char *rsrc, id_t id, timespec_t *interval,
uint_t flags, char **errstr, rcm_info_t **infop)
{
rcm_log_message(RCM_TRACE1, "MPXIO: suspend(%s)\n", rsrc);
return (RCM_SUCCESS);
}
/*
* Nothing is implemented for resume operations.
*/
static int
mpxio_resume(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
char **errstr, rcm_info_t **infop)
{
rcm_log_message(RCM_TRACE1, "MPXIO: resume(%s)\n", rsrc);
return (RCM_SUCCESS);
}
/*
* MPxIO has no policy against offlining. If disks will be affected, then
* base the return value for this request on the results of offlining the
* list of disks. Otherwise succeed.
*/
static int
mpxio_offline(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
char **errstr, rcm_info_t **infop)
{
char **clients = NULL;
int rv = RCM_SUCCESS;
rcm_log_message(RCM_TRACE1, "MPXIO: offline(%s)\n", rsrc);
(void) mutex_lock(&mpxio_lock);
if (get_affected_clients(hdl, rsrc, CMD_OFFLINE, flags, &clients) < 0) {
*errstr = strdup(gettext("Cannot lookup clients."));
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
if (clients) {
rv = rcm_request_offline_list(hdl, clients, flags, infop);
if (rv != RCM_SUCCESS)
*errstr = strdup(MPXIO_MSG_LASTPATH);
free(clients);
}
(void) mutex_unlock(&mpxio_lock);
return (rv);
}
/*
* If disks are affected, then they are probably offline and we need to
* propagate this online notification to them.
*/
static int
mpxio_online(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
char **errstr, rcm_info_t **infop)
{
char **clients;
int rv = RCM_SUCCESS;
rcm_log_message(RCM_TRACE1, "MPXIO: online(%s)\n", rsrc);
(void) mutex_lock(&mpxio_lock);
if (get_affected_clients(hdl, rsrc, CMD_ONLINE, flags, &clients) < 0) {
*errstr = strdup(gettext("Cannot lookup clients."));
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
if (clients) {
rv = rcm_notify_online_list(hdl, clients, flags, infop);
free(clients);
}
(void) mutex_unlock(&mpxio_lock);
return (rv);
}
/*
* If clients are affected, then they are probably offline and we need to
* propagate this removal notification to them. We can also remove the
* cache entry for this PHCI. If that leaves its group empty, then the
* group will be removed during the next register callback.
*/
static int
mpxio_remove(rcm_handle_t *hdl, char *rsrc, id_t id, uint_t flags,
char **errstr, rcm_info_t **infop)
{
char **clients;
int rv = RCM_SUCCESS;
rcm_log_message(RCM_TRACE1, "MPXIO: remove(%s)\n", rsrc);
(void) mutex_lock(&mpxio_lock);
if (get_affected_clients(hdl, rsrc, CMD_REMOVE, flags, &clients) < 0) {
*errstr = strdup(gettext("Cannot lookup clients."));
(void) mutex_unlock(&mpxio_lock);
return (RCM_FAILURE);
}
if (clients) {
rv = rcm_notify_remove_list(hdl, clients, flags, infop);
free(clients);
}
(void) mutex_unlock(&mpxio_lock);
return (rv);
}
/*
* Returns a string representation of a given libdevinfo path state.
*/
static char *
s_state(di_path_state_t state)
{
switch (state) {
case DI_PATH_STATE_ONLINE:
return ("online");
case DI_PATH_STATE_OFFLINE:
return ("offline");
case DI_PATH_STATE_STANDBY:
return ("standby");
case DI_PATH_STATE_FAULT:
return ("faulted");
default:
return ("<unknown>");
}
}
static int
get_affected_clients(rcm_handle_t *hdl, char *rsrc, int cmd, int flags,
char ***clientsp)
{
int nclients = 0;
phci_t phci;
group_t *group;
char **clients = NULL;
/* Build a dummy phci_t for use with bsearch(). */
phci.path = rsrc;
/* Analyze the effects upon each group. */
for (group = group_list; group != NULL; group = group->next) {
/* If the PHCI isn't in the group, then no effects. Skip. */
if (bsearch(&phci, group->phcis, group->nphcis, sizeof (phci_t),
compare_phci) == NULL)
continue;
/*
* Merge in the clients. All clients are merged in for getinfo
* operations. Otherwise it's contingent upon a state change
* being transferred to the clients as a result of changing
* the PHCI's state.
*/
if ((cmd == CMD_GETINFO) ||
detect_client_change(hdl, cmd, flags, group, rsrc)) {
if (merge_clients(&nclients, &clients, group) < 0) {
free_clients(nclients, clients);
return (-1);
}
}
}
/* Return the array of affected disks */
*clientsp = clients;
return (0);
}
/*
* Iterates through the members of a PHCI list, returning the entry
* corresponding to the named PHCI resource. Returns NULL when the lookup
* fails.
*/
static phci_list_t *
lookup_phci(char *rsrc)
{
phci_list_t *reg;
for (reg = reg_list; reg != NULL; reg = reg->next) {
if (strcmp(reg->phci.path, rsrc) == 0)
return (reg);
}
return (NULL);
}
/*
* Tests whether or not an operation on a specific PHCI resource would affect
* the array of client devices attached to the PHCI's MPxIO group.
*
* Returns: 1 if clients would be affected, 0 if not.
*/
static int
detect_client_change(rcm_handle_t *hdl, int cmd, int flags, group_t *group,
char *rsrc)
{
int i;
int state;
/*
* Perform a full set analysis on the set of redundant PHCIs. When
* there are no unaffected and online PHCIs, then changing the state
* of the named PHCI results in a client state change.
*/
for (i = 0; i < group->nphcis; i++) {
/* Filter the named resource out of the analysis */
if (strcmp(group->phcis[i].path, rsrc) == 0)
continue;
/*
* If we find a path that's in the ONLINE or STANDBY state
* that would be left over in the system after completing
* whatever DR or hotplugging operation is in progress, then
* return a 0.
*/
if ((group->phcis[i].state == DI_PATH_STATE_ONLINE) ||
(group->phcis[i].state == DI_PATH_STATE_STANDBY)) {
if (rcm_get_rsrcstate(hdl, group->phcis[i].path, &state)
!= RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
"MPXIO: Failed to query resource state\n");
continue;
}
rcm_log_message(RCM_TRACE2, "MPXIO: state of %s: %d\n",
group->phcis[i].path, state);
if (state == RCM_STATE_ONLINE) {
return (0);
}
}
}
/*
* The analysis above didn't find a redundant path to take over. So
* report that the state of the client resources will change.
*/
return (1);
}
/*
* Merges the client disks connected to a particular MPxIO group in with a
* previous array of disk clients. The result is to adjust the 'nclients'
* value with the new count of disks in the array, and to adjust the 'disks'
* value to be a larger array of disks including its original contents along
* with the current group's contents merged in.
*/
static int
merge_clients(int *nclients, char ***clientsp, group_t *group)
{
int i;
int old_nclients;
char **clients_new;
if (group->nclients) {
old_nclients = *nclients;
*nclients += group->nclients;
clients_new = realloc(*clientsp,
((*nclients) + 1) * sizeof (char *));
if (clients_new == NULL) {
rcm_log_message(RCM_ERROR,
"MPXIO: cannot reallocate client array (%s).\n",
strerror(errno));
return (-1);
}
for (i = old_nclients; i < (*nclients); i++) {
/*
* Don't allocate space for individual disks in the
* merged list. Just make references to the previously
* allocated strings in the group_t structs themselves.
*/
clients_new[i] = group->clients[i - old_nclients];
}
clients_new[(*nclients)] = NULL;
*clientsp = clients_new;
}
return (0);
}
/*
* A libdevinfo di_walk_node() callback. It's passed an integer pointer as an
* argument, and it increments the integer each time it encounters an MPxIO
* client. By initializing the integer to zero and doing a libdevinfo walk with
* this function, the total count of MPxIO clients in the system can be found.
*/
static int
get_nclients(di_node_t dinode, void *arg)
{
int *nclients = arg;
if (is_client(dinode))
(*nclients)++;
return (DI_WALK_CONTINUE);
}
/*
* Tests a libdevinfo node to determine if it's an MPxIO client.
*
* Returns: non-zero for true, 0 for false.
*/
static int
is_client(di_node_t dinode)
{
return (di_path_client_next_path(dinode, DI_PATH_NIL) != DI_PATH_NIL);
}
/*
* After a new group_list has been constructed, this refreshes the RCM
* registrations and the reg_list contents. It uses a clock like algorithm
* with reference bits in the reg_list to know which registrants are new or
* old.
*/
static void
refresh_regs(rcm_handle_t *hdl)
{
int i;
group_t *group;
phci_list_t *reg;
phci_list_t *prev_reg;
/*
* First part of the clock-like algorithm: clear reference bits.
*/
for (reg = reg_list; reg != NULL; reg = reg->next)
reg->referenced = CACHE_STALE;
/*
* Second part of the clock-like algorithm: set the reference bits
* on every registrant that's still active. (Also add new list nodes
* for new registrants.)
*/
for (group = group_list; group != NULL; group = group->next) {
for (i = 0; i < group->nphcis; i++) {
/*
* If already stale in the registrants list, just set
* its reference bit to REFERENCED and update its state.
*/
if ((reg = lookup_phci(group->phcis[i].path)) != NULL) {
if (reg->referenced == CACHE_STALE)
reg->referenced = CACHE_REFERENCED;
reg->phci.state = group->phcis[i].state;
continue;
}
/*
* Otherwise, build a new list node and mark it NEW.
*/
reg = (phci_list_t *)calloc(1, sizeof (*reg));
if (reg == NULL) {
rcm_log_message(RCM_ERROR,
"MPXIO: cannot allocate phci_list (%s).\n",
strerror(errno));
continue;
}
reg->phci.path = strdup(group->phcis[i].path);
if (reg->phci.path == NULL) {
free(reg);
rcm_log_message(RCM_ERROR,
"MPXIO: cannot allocate phci path (%s).\n",
strerror(errno));
continue;
}
reg->phci.state = group->phcis[i].state;
reg->referenced = CACHE_NEW;
/* Link it at the head of reg_list */
reg->next = reg_list;
reg_list = reg;
}
}
/*
* Final part of the clock algorithm: unregister stale entries, and
* register new entries. Stale entries get removed from the list.
*/
reg = reg_list;
prev_reg = NULL;
while (reg) {
/* Unregister and remove stale entries. */
if (reg->referenced == CACHE_STALE) {
(void) rcm_unregister_interest(hdl, reg->phci.path, 0);
free(reg->phci.path);
if (prev_reg == NULL) {
reg_list = reg->next;
free(reg);
reg = reg_list;
} else {
prev_reg->next = reg->next;
free(reg);
reg = prev_reg->next;
}
continue;
}
/* Register new entries. */
if (reg->referenced == CACHE_NEW) {
if (rcm_register_interest(hdl, reg->phci.path, 0, NULL)
!= RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
"MPXIO: failed to register %s (%s).\n",
reg->phci.path, strerror(errno));
}
}
prev_reg = reg;
reg = reg->next;
}
}
/*
* A libdevinfo di_walk_node() callback that builds up the MPxIO group list.
*
* Every node encountered that's a client node is added into a group's client
* list. Whenever a group doesn't already exist with a matching set of
* related PHCIs, then a new group is constructed and put at the head of the
* group list.
*/
static int
build_groups(di_node_t dinode, void *arg)
{
int i = 0;
int nphcis = 0;
int *nclients = (int *)arg;
phci_t *phcis;
group_t *group;
di_node_t phcinode;
di_path_t dipath = DI_PATH_NIL;
/* Safety check */
if (nclients == NULL)
return (DI_WALK_TERMINATE);
/*
* Build a sorted array of PHCIs pertaining to the client.
*/
while ((dipath =
di_path_client_next_path(dinode, dipath)) != DI_PATH_NIL)
nphcis++;
/* Skip non-clients. */
if (nphcis == 0)
return (DI_WALK_CONTINUE);
if ((phcis = (phci_t *)calloc(nphcis, sizeof (phci_t))) == NULL) {
rcm_log_message(RCM_ERROR,
"MPXIO: failed to allocate client's PHCIs (%s).\n",
strerror(errno));
return (DI_WALK_TERMINATE);
}
while ((dipath =
di_path_client_next_path(dinode, dipath)) != DI_PATH_NIL) {
phcinode = di_path_phci_node(dipath);
if (phcinode == DI_NODE_NIL) {
free_phcis(i, phcis); /* free preceeding PHCIs */
rcm_log_message(RCM_ERROR,
"MPXIO: client appears to have no PHCIs.\n");
return (DI_WALK_TERMINATE);
}
if ((phcis[i].path = get_rsrcname(phcinode)) == NULL) {
free_phcis(i, phcis);
return (DI_WALK_TERMINATE);
}
phcis[i].state = di_path_state(dipath);
i++;
}
qsort(phcis, nphcis, sizeof (phci_t), compare_phci);
/*
* Compare that PHCI set to each existing group's set. We just add
* the client to the group and exit successfully once a match is made.
* Falling out of this loop means no match was found.
*/
for (group = group_list; group != NULL; group = group->next) {
/* There is no match if the number of PHCIs is inequal */
if (nphcis != group->nphcis)
continue;
/* Compare the PHCIs linearly (which is okay; they're sorted) */
for (i = 0; i < nphcis; i++)
if (strcmp(phcis[i].path, group->phcis[i].path) != 0)
break;
/*
* If the loop above completed, we have a match. Add the client
* to the group's disk array in that case, and return
* successfully.
*/
if (i == nphcis) {
free_phcis(nphcis, phcis);
if ((group->clients[group->nclients] =
get_rsrcname(dinode)) == NULL)
return (DI_WALK_TERMINATE);
group->nclients++;
return (DI_WALK_CONTINUE);
}
}
/* The loop above didn't find a match. So build a new group. */
if ((group = (group_t *)calloc(1, sizeof (*group))) == NULL) {
rcm_log_message(RCM_ERROR,
"MPXIO: failed to allocate PHCI group (%s).\n",
strerror(errno));
free_phcis(nphcis, phcis);
return (DI_WALK_TERMINATE);
}
if ((group->clients = (char **)calloc(*nclients, sizeof (char *))) ==
NULL) {
free(group);
free_phcis(nphcis, phcis);
return (DI_WALK_TERMINATE);
}
group->nphcis = nphcis;
group->phcis = phcis;
if ((group->clients[0] = get_rsrcname(dinode)) == NULL) {
free_group(group);
return (DI_WALK_TERMINATE);
}
group->nclients = 1;
/* Link the group into the group list and return successfully. */
group->next = group_list;
group_list = group;
return (DI_WALK_CONTINUE);
}
/*
* For bsearch() and qsort(). Returns the results of a strcmp() on the names
* of two phci_t's.
*/
static int
compare_phci(const void *arg1, const void *arg2)
{
phci_t *p1 = (phci_t *)arg1;
phci_t *p2 = (phci_t *)arg2;
if ((p1 == NULL) || (p2 == NULL)) {
if (p1 != NULL)
return (-1);
else if (p2 != NULL)
return (1);
return (0);
}
return (strcmp(p1->path, p2->path));
}
/*
* Free the whole list of group's in the global group_list.
*/
static void
free_grouplist()
{
group_t *group = group_list;
group_t *next;
while (group) {
next = group->next;
free_group(group);
group = next;
}
group_list = NULL;
}
/*
* Free the contents of a single group_t.
*/
static void
free_group(group_t *group)
{
if (group) {
free_phcis(group->nphcis, group->phcis);
free_clients(group->nclients, group->clients);
free(group);
}
}
/*
* Free an array of clients.
*/
static void
free_clients(int nclients, char **clients)
{
int i;
if (clients != NULL) {
if (nclients > 0) {
for (i = 0; i < nclients; i++)
if (clients[i])
free(clients[i]);
}
free(clients);
}
}
/*
* Free an array of phci_t's.
*/
static void
free_phcis(int nphcis, phci_t *phcis)
{
int i;
if ((phcis != NULL) && (nphcis > 0)) {
for (i = 0; i < nphcis; i++)
if (phcis[i].path)
free(phcis[i].path);
free(phcis);
}
}
/*
* Converts a libdevinfo node into a /devices path. Caller must free results.
*/
static char *
get_rsrcname(di_node_t dinode)
{
int len;
char *rsrcname;
char *devfspath;
char name[MAXPATHLEN];
if ((devfspath = di_devfs_path(dinode)) == NULL) {
rcm_log_message(RCM_ERROR, "MPXIO: resource has null path.\n");
return (NULL);
}
len = snprintf(name, sizeof (name), "/devices%s", devfspath);
di_devfs_path_free(devfspath);
if (len >= sizeof (name)) {
rcm_log_message(RCM_ERROR, "MPXIO: resource path too long.\n");
return (NULL);
}
if ((rsrcname = strdup(name)) == NULL)
rcm_log_message(RCM_ERROR,
"MPXIO: failed to allocate resource name (%s).\n",
strerror(errno));
return (rsrcname);
}