OpenSolaris_b135/cmd/rcm_daemon/common/network_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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* This RCM module adds support to the RCM framework for an abstract
* namespace for network devices (DLPI providers).
*/
#include <alloca.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <string.h>
#include <synch.h>
#include <libintl.h>
#include <errno.h>
#include <libdevinfo.h>
#include <sys/types.h>
#include <net/if.h>
#include <libdllink.h>
#include "rcm_module.h"
/*
* Definitions
*/
#ifndef lint
#define _(x) gettext(x)
#else
#define _(x) x
#endif
#define CACHE_STALE 1 /* flags */
#define CACHE_NEW 2 /* flags */
/* operations */
#define NET_OFFLINE 1
#define NET_ONLINE 2
#define NET_REMOVE 3
#define NET_SUSPEND 4
#define NET_RESUME 5
typedef struct net_cache
{
char *resource;
datalink_id_t linkid;
int flags;
struct net_cache *next;
struct net_cache *prev;
} net_cache_t;
static net_cache_t cache_head;
static net_cache_t cache_tail;
static mutex_t cache_lock;
static int events_registered = 0;
static dladm_handle_t dld_handle = NULL;
/* module interface routines */
static int net_register(rcm_handle_t *);
static int net_unregister(rcm_handle_t *);
static int net_getinfo(rcm_handle_t *, char *, id_t, uint_t, char **,
char **, nvlist_t *, rcm_info_t **);
static int net_suspend(rcm_handle_t *, char *, id_t, timespec_t *,
uint_t, char **, rcm_info_t **);
static int net_resume(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int net_offline(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int net_online(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int net_remove(rcm_handle_t *, char *, id_t, uint_t, char **,
rcm_info_t **);
static int net_notify_event(rcm_handle_t *, char *, id_t, uint_t,
char **, nvlist_t *, rcm_info_t **);
/* module private routines */
static void free_cache(void);
static void update_cache(rcm_handle_t *hd);
static int devfs_entry(di_node_t node, di_minor_t minor, void *arg);
static void cache_remove(net_cache_t *node);
static net_cache_t *cache_lookup(const char *resource);
static void free_node(net_cache_t *);
static void cache_insert(net_cache_t *);
/*
* Module-Private data
*/
static struct rcm_mod_ops net_ops = {
RCM_MOD_OPS_VERSION,
net_register,
net_unregister,
net_getinfo,
net_suspend,
net_resume,
net_offline,
net_online,
net_remove,
NULL,
NULL,
net_notify_event
};
/*
* Module Interface Routines
*/
/*
* rcm_mod_init()
*
* Update registrations, and return the ops structure.
*/
struct rcm_mod_ops *
rcm_mod_init(void)
{
dladm_status_t status;
char errmsg[DLADM_STRSIZE];
cache_head.next = &cache_tail;
cache_head.prev = NULL;
cache_tail.prev = &cache_head;
cache_tail.next = NULL;
(void) mutex_init(&cache_lock, NULL, NULL);
if ((status = dladm_open(&dld_handle)) != DLADM_STATUS_OK) {
rcm_log_message(RCM_WARNING,
"NET: mod_init failed: cannot open datalink handle: %s\n",
dladm_status2str(status, errmsg));
return (NULL);
}
/* Return the ops vectors */
return (&net_ops);
}
/*
* rcm_mod_info()
*
* Return a string describing this module.
*/
const char *
rcm_mod_info(void)
{
return ("Network namespace module 1.13");
}
/*
* rcm_mod_fini()
*
* Destroy the cache.
*/
int
rcm_mod_fini(void)
{
free_cache();
(void) mutex_destroy(&cache_lock);
dladm_close(dld_handle);
return (RCM_SUCCESS);
}
/*
* net_register()
*
* Make sure the cache is properly sync'ed, and its registrations
* are in order.
*
* Locking: the cache is locked by update_cache, and is held
* throughout update_cache's execution because it reads and
* possibly modifies cache links continuously.
*/
static int
net_register(rcm_handle_t *hd)
{
update_cache(hd);
/*
* Need to register interest in all new resources
* getting attached, so we get attach event notifications
*/
if (!events_registered) {
if (rcm_register_event(hd, RCM_RESOURCE_PHYSLINK_NEW, 0, NULL)
!= RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
_("NET: failed to register %s\n"),
RCM_RESOURCE_PHYSLINK_NEW);
return (RCM_FAILURE);
} else {
rcm_log_message(RCM_DEBUG, _("NET: registered %s \n"),
RCM_RESOURCE_PHYSLINK_NEW);
events_registered++;
}
}
return (RCM_SUCCESS);
}
/*
* net_unregister()
*
* Manually walk through the cache, unregistering all the networks.
*
* Locking: the cache is locked throughout the execution of this routine
* because it reads and modifies cache links continuously.
*/
static int
net_unregister(rcm_handle_t *hd)
{
net_cache_t *probe;
assert(hd != NULL);
/* Walk the cache, unregistering everything */
(void) mutex_lock(&cache_lock);
probe = cache_head.next;
while (probe != &cache_tail) {
(void) rcm_unregister_interest(hd, probe->resource, 0);
cache_remove(probe);
free_node(probe);
probe = cache_head.next;
}
(void) mutex_unlock(&cache_lock);
/*
* Need to unregister interest in all new resources
*/
if (events_registered) {
if (rcm_unregister_event(hd, RCM_RESOURCE_PHYSLINK_NEW, 0)
!= RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
_("NET: failed to unregister %s\n"),
RCM_RESOURCE_PHYSLINK_NEW);
return (RCM_FAILURE);
} else {
rcm_log_message(RCM_DEBUG, _("NET: unregistered %s\n"),
RCM_RESOURCE_PHYSLINK_NEW);
events_registered--;
}
}
return (RCM_SUCCESS);
}
/*
* Since all we do is pass operations thru, we provide a general
* routine for passing through operations.
*/
/*ARGSUSED*/
static int
net_passthru(rcm_handle_t *hd, int op, const char *rsrc, uint_t flag,
char **reason, rcm_info_t **dependent_reason, void *arg)
{
net_cache_t *node;
char *exported;
datalink_id_t linkid;
int len;
int rv;
/*
* Lock the cache just long enough to extract information about this
* resource.
*/
(void) mutex_lock(&cache_lock);
node = cache_lookup(rsrc);
if (!node) {
rcm_log_message(RCM_WARNING,
_("NET: unrecognized resource %s\n"), rsrc);
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
/*
* Since node could be freed after we drop cache_lock, allocate a
* stack-local copy. We don't use malloc() because some of the
* operations (such as NET_REMOVE) are not allowed to fail. Note
* that exported is never more than MAXPATHLEN bytes.
*/
len = strlen("SUNW_datalink/") + LINKID_STR_WIDTH + 1;
exported = alloca(len);
linkid = node->linkid;
(void) snprintf(exported, len, "SUNW_datalink/%u", linkid);
/*
* Remove notifications are unconditional in the RCM state model,
* so it's safe to remove the node from the cache at this point.
* And we need to remove it so that we will recognize it as a new
* resource following the reattachment of the resource.
*/
if (op == NET_REMOVE) {
cache_remove(node);
free_node(node);
}
(void) mutex_unlock(&cache_lock);
switch (op) {
case NET_SUSPEND:
rv = rcm_request_suspend(hd, exported, flag,
(timespec_t *)arg, dependent_reason);
break;
case NET_OFFLINE:
rv = rcm_request_offline(hd, exported, flag, dependent_reason);
break;
case NET_ONLINE:
rv = rcm_notify_online(hd, exported, flag, dependent_reason);
break;
case NET_REMOVE:
rv = rcm_notify_remove(hd, exported, flag, dependent_reason);
if (rv == RCM_SUCCESS) {
rcm_log_message(RCM_DEBUG,
_("NET: mark link %d as removed\n"), linkid);
/*
* Delete active linkprop before this active link
* is deleted.
*/
(void) dladm_set_linkprop(dld_handle, linkid, NULL,
NULL, 0, DLADM_OPT_ACTIVE);
(void) dladm_destroy_datalink_id(dld_handle, linkid,
DLADM_OPT_ACTIVE);
}
break;
case NET_RESUME:
rv = rcm_notify_resume(hd, exported, flag, dependent_reason);
break;
default:
rcm_log_message(RCM_WARNING,
_("NET: bad RCM operation %1$d for %2$s\n"), op, exported);
errno = EINVAL;
return (RCM_FAILURE);
}
if (rv != RCM_SUCCESS) {
char format[256];
(void) snprintf(format, sizeof (format),
_("RCM operation on dependent %s did not succeed"),
exported);
rcm_log_message(RCM_WARNING, "NET: %s\n", format);
}
return (rv);
}
/*
* net_offline()
*
* Determine dependents of the resource being offlined, and offline
* them all.
*/
static int
net_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
char **reason, rcm_info_t **dependent_reason)
{
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
assert(reason != NULL);
assert(dependent_reason != NULL);
rcm_log_message(RCM_TRACE1, _("NET: offline(%s)\n"), rsrc);
return (net_passthru(hd, NET_OFFLINE, rsrc, flags, reason,
dependent_reason, NULL));
}
/*
* net_online()
*
* Online the previously offlined resource, and online its dependents.
*/
static int
net_online(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **reason,
rcm_info_t **dependent_reason)
{
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
rcm_log_message(RCM_TRACE1, _("NET: online(%s)\n"), rsrc);
return (net_passthru(hd, NET_ONLINE, rsrc, flag, reason,
dependent_reason, NULL));
}
/*
* net_getinfo()
*
* Gather usage information for this resource.
*
* Locking: the cache is locked while this routine looks up the
* resource and extracts copies of any piece of information it needs.
* The cache is then unlocked, and this routine performs the rest of
* its functions without touching any part of the cache.
*/
/*ARGSUSED*/
static int
net_getinfo(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag,
char **info, char **errstr, nvlist_t *proplist, rcm_info_t **depend_info)
{
int len;
dladm_status_t status;
char link[MAXLINKNAMELEN];
char errmsg[DLADM_STRSIZE];
char *exported;
const char *info_fmt;
net_cache_t *node;
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
assert(info != NULL);
assert(depend_info != NULL);
rcm_log_message(RCM_TRACE1, _("NET: getinfo(%s)\n"), rsrc);
info_fmt = _("Network interface %s");
(void) mutex_lock(&cache_lock);
node = cache_lookup(rsrc);
if (!node) {
rcm_log_message(RCM_WARNING,
_("NET: unrecognized resource %s\n"), rsrc);
(void) mutex_unlock(&cache_lock);
errno = ENOENT;
return (RCM_FAILURE);
}
len = strlen(info_fmt) + MAXLINKNAMELEN + 1;
if ((status = dladm_datalink_id2info(dld_handle, node->linkid, NULL,
NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) {
rcm_log_message(RCM_ERROR,
_("NET: usage(%s) get link name failure(%s)\n"),
node->resource, dladm_status2str(status, errmsg));
(void) mutex_unlock(&cache_lock);
return (RCM_FAILURE);
} else if ((*info = (char *)malloc(len)) == NULL) {
rcm_log_message(RCM_ERROR, _("NET: malloc failure"));
(void) mutex_unlock(&cache_lock);
return (RCM_FAILURE);
}
/* Fill in the string */
(void) snprintf(*info, len, info_fmt, link);
len = strlen("SUNW_datalink/") + LINKID_STR_WIDTH + 1;
exported = malloc(len);
if (!exported) {
rcm_log_message(RCM_ERROR, _("NET: allocation failure"));
free(*info);
(void) mutex_unlock(&cache_lock);
return (RCM_FAILURE);
}
(void) snprintf(exported, len, "SUNW_datalink/%u", node->linkid);
(void) mutex_unlock(&cache_lock);
/* Get dependent info if requested */
if ((flag & RCM_INCLUDE_DEPENDENT) || (flag & RCM_INCLUDE_SUBTREE)) {
(void) rcm_get_info(hd, exported, flag, depend_info);
}
(void) nvlist_add_string(proplist, RCM_CLIENT_NAME, "SunOS");
(void) nvlist_add_string_array(proplist, RCM_CLIENT_EXPORTS,
&exported, 1);
free(exported);
return (RCM_SUCCESS);
}
/*
* net_suspend()
*
* Notify all dependents that the resource is being suspended.
* Since no real operation is involved, QUERY or not doesn't matter.
*
* Locking: the cache is only used to retrieve some information about
* this resource, so it is only locked during that retrieval.
*/
static int
net_suspend(rcm_handle_t *hd, char *rsrc, id_t id, timespec_t *interval,
uint_t flag, char **reason, rcm_info_t **dependent_reason)
{
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
assert(interval != NULL);
assert(reason != NULL);
assert(dependent_reason != NULL);
rcm_log_message(RCM_TRACE1, _("NET: suspend(%s)\n"), rsrc);
return (net_passthru(hd, NET_SUSPEND, rsrc, flag, reason,
dependent_reason, (void *)interval));
}
/*
* net_resume()
*
* Resume all the dependents of a suspended network.
*
* Locking: the cache is only used to retrieve some information about
* this resource, so it is only locked during that retrieval.
*/
static int
net_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **info,
rcm_info_t **dependent_info)
{
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
assert(info != NULL);
assert(dependent_info != NULL);
rcm_log_message(RCM_TRACE1, _("NET: resume(%s)\n"), rsrc);
return (net_passthru(hd, NET_RESUME, rsrc, flag, info, dependent_info,
NULL));
}
/*
* net_remove()
*
* This is another NO-OP for us, we just passthru the information. We
* don't need to remove it from our cache. We don't unregister
* interest at this point either; the network device name is still
* around. This way we don't have to change this logic when we
* gain the ability to learn about DR attach operations.
*/
static int
net_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **info,
rcm_info_t **dependent_info)
{
assert(hd != NULL);
assert(rsrc != NULL);
assert(id == (id_t)0);
assert(info != NULL);
assert(dependent_info != NULL);
rcm_log_message(RCM_TRACE1, _("NET: remove(%s)\n"), rsrc);
return (net_passthru(hd, NET_REMOVE, rsrc, flag, info, dependent_info,
NULL));
}
/*
* Cache management routines. Note that the cache is implemented as a
* trivial linked list, and is only required because RCM doesn't
* provide enough state about our own registrations back to us. This
* linked list implementation probably clobbers the CPU cache pretty
* well.
*/
/*
* cache_lookup()
*
* Get a cache node for a resource. Call with cache lock held.
*/
static net_cache_t *
cache_lookup(const char *resource)
{
net_cache_t *probe;
probe = cache_head.next;
while (probe != &cache_tail) {
if (probe->resource &&
(strcmp(resource, probe->resource) == 0)) {
return (probe);
}
probe = probe->next;
}
return (NULL);
}
/*
* free_node()
*
* Free a node. Make sure it isn't in the list!
*/
static void
free_node(net_cache_t *node)
{
if (node) {
free(node->resource);
free(node);
}
}
/*
* cache_insert()
*
* Call with the cache_lock held.
*/
static void
cache_insert(net_cache_t *node)
{
/* insert at the head for best performance */
node->next = cache_head.next;
node->prev = &cache_head;
node->next->prev = node;
node->prev->next = node;
}
/*
* cache_remove()
*
* Call with the cache_lock held.
*/
static void
cache_remove(net_cache_t *node)
{
node->next->prev = node->prev;
node->prev->next = node->next;
node->next = NULL;
node->prev = NULL;
}
/*
* devfs_entry()
*
* Call with the cache_lock held.
*/
/*ARGSUSED*/
static int
devfs_entry(di_node_t node, di_minor_t minor, void *arg)
{
char *devfspath;
char resource[MAXPATHLEN];
char dev[MAXNAMELEN];
datalink_id_t linkid;
char *drv;
char *cp;
net_cache_t *probe;
cp = di_minor_nodetype(minor);
if ((cp == NULL) || (strcmp(cp, DDI_NT_NET))) {
/* doesn't look like a network device */
return (DI_WALK_CONTINUE);
}
drv = di_driver_name(node);
if (drv == NULL) {
/* what else can we do? */
return (DI_WALK_CONTINUE);
}
devfspath = di_devfs_path(node);
if (!devfspath) {
/* no devfs path?!? */
rcm_log_message(RCM_DEBUG, _("NET: missing devfs path\n"));
return (DI_WALK_CONTINUE);
}
if (strncmp("/pseudo", devfspath, strlen("/pseudo")) == 0) {
/* ignore pseudo devices, probably not really NICs */
rcm_log_message(RCM_DEBUG,
_("NET: ignoring pseudo device %s\n"), devfspath);
di_devfs_path_free(devfspath);
return (DI_WALK_CONTINUE);
}
(void) snprintf(resource, sizeof (resource), "/devices%s", devfspath);
di_devfs_path_free(devfspath);
(void) snprintf(dev, sizeof (dev), "%s%d", drv, di_instance(node));
if (dladm_dev2linkid(dld_handle, dev, &linkid) != DLADM_STATUS_OK) {
rcm_log_message(RCM_DEBUG,
_("NET: failed to find the linkid for %s\n"), dev);
return (DI_WALK_CONTINUE);
}
probe = cache_lookup(resource);
if (probe != NULL) {
rcm_log_message(RCM_DEBUG,
_("NET: %s already registered (linkid %u)\n"),
resource, linkid);
probe->linkid = linkid;
probe->flags &= ~(CACHE_STALE);
} else {
rcm_log_message(RCM_DEBUG,
_("NET: %s is new resource (linkid %u)\n"),
resource, linkid);
probe = calloc(1, sizeof (net_cache_t));
if (!probe) {
rcm_log_message(RCM_ERROR, _("NET: malloc failure"));
return (DI_WALK_CONTINUE);
}
probe->resource = strdup(resource);
probe->linkid = linkid;
if (!probe->resource) {
free_node(probe);
return (DI_WALK_CONTINUE);
}
probe->flags |= CACHE_NEW;
cache_insert(probe);
}
return (DI_WALK_CONTINUE);
}
/*
* update_cache()
*
* The devinfo tree walking code is lifted from ifconfig.c.
*/
static void
update_cache(rcm_handle_t *hd)
{
net_cache_t *probe;
di_node_t root;
int rv;
(void) mutex_lock(&cache_lock);
/* first we walk the entire cache, marking each entry stale */
probe = cache_head.next;
while (probe != &cache_tail) {
probe->flags |= CACHE_STALE;
probe = probe->next;
}
root = di_init("/", DINFOSUBTREE | DINFOMINOR);
if (root == DI_NODE_NIL) {
goto done;
}
(void) di_walk_minor(root, DDI_NT_NET, DI_CHECK_ALIAS, NULL,
devfs_entry);
di_fini(root);
probe = cache_head.next;
while (probe != &cache_tail) {
net_cache_t *freeit;
if (probe->flags & CACHE_STALE) {
(void) rcm_unregister_interest(hd, probe->resource, 0);
rcm_log_message(RCM_DEBUG, _("NET: unregistered %s\n"),
probe->resource);
freeit = probe;
probe = probe->next;
cache_remove(freeit);
free_node(freeit);
continue;
}
if (!(probe->flags & CACHE_NEW)) {
probe = probe->next;
continue;
}
rcm_log_message(RCM_DEBUG, _("NET: registering %s\n"),
probe->resource);
rv = rcm_register_interest(hd, probe->resource, 0, NULL);
if (rv != RCM_SUCCESS) {
rcm_log_message(RCM_ERROR,
_("NET: failed to register %s\n"),
probe->resource);
} else {
rcm_log_message(RCM_DEBUG,
_("NET: registered %s as SUNW_datalink/%u\n"),
probe->resource, probe->linkid);
probe->flags &= ~(CACHE_NEW);
}
probe = probe->next;
}
done:
(void) mutex_unlock(&cache_lock);
}
/*
* free_cache()
*/
static void
free_cache(void)
{
net_cache_t *probe;
(void) mutex_lock(&cache_lock);
probe = cache_head.next;
while (probe != &cache_tail) {
cache_remove(probe);
free_node(probe);
probe = cache_head.next;
}
(void) mutex_unlock(&cache_lock);
}
/*
* net_notify_event - Project private implementation to receive new
* resource events. It intercepts all new resource
* events. If the new resource is a network resource,
* update the physical link cache.
*/
/*ARGSUSED*/
static int
net_notify_event(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
char **errorp, nvlist_t *nvl, rcm_info_t **depend_info)
{
nvpair_t *nvp = NULL;
uint64_t id64 = (uint64_t)DATALINK_INVALID_LINKID;
boolean_t reconfigured = B_FALSE;
rcm_log_message(RCM_TRACE1, _("NET: notify_event(%s)\n"), rsrc);
if (strcmp(rsrc, RCM_RESOURCE_PHYSLINK_NEW) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized event for %s\n"), rsrc);
errno = EINVAL;
return (RCM_FAILURE);
}
/* Update cache to reflect latest physical links */
update_cache(hd);
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
if (strcmp(nvpair_name(nvp), RCM_NV_RECONFIGURED) == 0) {
if (nvpair_value_boolean_value(nvp,
&reconfigured) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized %s event data\n"),
RCM_NV_RECONFIGURED);
errno = EINVAL;
return (RCM_FAILURE);
}
rcm_log_message(RCM_TRACE1,
"NET: %s event data (%sreconfiguration)\n",
RCM_NV_RECONFIGURED, reconfigured ? "" : "not ");
}
if (strcmp(nvpair_name(nvp), RCM_NV_LINKID) == 0) {
if (nvpair_value_uint64(nvp, &id64) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized %s event data\n"),
RCM_NV_LINKID);
errno = EINVAL;
return (RCM_FAILURE);
}
rcm_log_message(RCM_TRACE1,
"NET: %s event data (linkid %d)\n", RCM_NV_LINKID,
(datalink_id_t)id64);
}
}
if ((datalink_id_t)id64 == DATALINK_INVALID_LINKID) {
rcm_log_message(RCM_INFO, _("NET: invalid datalink\n"));
errno = EINVAL;
return (RCM_FAILURE);
}
/*
* If this is device reconfiguration, populate the LINK_NEW event
* to start the DR process.
*/
if (reconfigured) {
nvlist_t *nnvl = NULL;
rcm_log_message(RCM_TRACE1,
"NET: reconfigured data-link (id %d)\n",
(datalink_id_t)id64);
if ((nvlist_alloc(&nnvl, 0, 0) != 0) || (nvlist_add_uint64(nnvl,
RCM_NV_LINKID, id64) != 0) || (rcm_notify_event(hd,
RCM_RESOURCE_LINK_NEW, 0, nnvl, NULL) != RCM_SUCCESS)) {
nvlist_free(nnvl);
rcm_log_message(RCM_INFO,
_("NET: notify %s event failed\n"),
RCM_RESOURCE_LINK_NEW);
errno = EINVAL;
return (RCM_FAILURE);
}
nvlist_free(nnvl);
}
rcm_log_message(RCM_TRACE1,
_("NET: notify_event: device configuration complete\n"));
return (RCM_SUCCESS);
}