OpenSolaris_b135/uts/common/io/neti_stack.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.
*/
#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/rwlock.h>
#include <sys/errno.h>
#include <sys/queue.h>
#include <sys/sunddi.h>
#include <inet/common.h>
#include <inet/led.h>
#include <inet/ip.h>
#include <sys/neti.h>
#include <sys/zone.h>
#include <sys/sdt.h>
typedef boolean_t napplyfn_t(neti_stack_t *, void *);
static void *neti_stack_init(netstackid_t stackid, netstack_t *ns);
static void neti_stack_fini(netstackid_t stackid, void *arg);
static net_instance_int_t *net_instance_int_create(net_instance_t *nin,
net_instance_int_t *parent);
static void neti_stack_shutdown(netstackid_t stackid, void *arg);
static void net_instance_int_free(net_instance_int_t *nini);
static boolean_t neti_stack_apply_create(neti_stack_t *, void *);
static boolean_t neti_stack_apply_destroy(neti_stack_t *, void *);
static boolean_t neti_stack_apply_shutdown(neti_stack_t *, void *);
static void neti_apply_all_instances(neti_stack_t *, napplyfn_t *);
static void neti_apply_all_stacks(void *, napplyfn_t *);
static boolean_t wait_for_nini_inprogress(neti_stack_t *,
net_instance_int_t *, uint32_t);
static nini_head_t neti_instance_list;
static neti_stack_head_t neti_stack_list;
static kmutex_t neti_stack_lock;
void
neti_init()
{
mutex_init(&neti_stack_lock, NULL, MUTEX_DRIVER, NULL);
LIST_INIT(&neti_instance_list);
LIST_INIT(&neti_stack_list);
/*
* We want to be informed each time a netstack is created or
* destroyed in the kernel.
*/
netstack_register(NS_NETI, neti_stack_init, neti_stack_shutdown,
neti_stack_fini);
}
void
neti_fini()
{
ASSERT(LIST_EMPTY(&neti_instance_list));
ASSERT(LIST_EMPTY(&neti_stack_list));
netstack_unregister(NS_NETI);
mutex_destroy(&neti_stack_lock);
}
/*
* Initialize the neti stack instance. Because this is called out of the
* netstack framework, it is not possible for it to be called twice with
* the same values for (stackid,ns). The same also applies to the other
* two functions used with netstack_register: neti_stack_shutdown and
* neti_stack_fini.
*/
static void *
neti_stack_init(netstackid_t stackid, netstack_t *ns)
{
net_instance_int_t *dup;
net_instance_int_t *n;
neti_stack_t *nts;
nts = kmem_zalloc(sizeof (*nts), KM_SLEEP);
LIST_INIT(&nts->nts_instances);
nts->nts_id = (netid_t)stackid;
nts->nts_stackid = stackid;
nts->nts_netstack = ns;
nts->nts_zoneid = netstackid_to_zoneid(stackid);
nts->nts_flags = NSF_ZONE_CREATE;
cv_init(&nts->nts_cv, NULL, CV_DRIVER, NULL);
mutex_init(&nts->nts_lock, NULL, MUTEX_DRIVER, NULL);
mutex_enter(&neti_stack_lock);
LIST_INSERT_HEAD(&neti_stack_list, nts, nts_next);
LIST_FOREACH(n, &neti_instance_list, nini_next) {
/*
* This function returns with the NSS_CREATE_NEEDED flag
* set in "dup", so it is adequately prepared for the
* upcoming apply.
*/
dup = net_instance_int_create(n->nini_instance, n);
mutex_enter(&nts->nts_lock);
LIST_INSERT_HEAD(&nts->nts_instances, dup, nini_next);
mutex_exit(&nts->nts_lock);
}
neti_apply_all_instances(nts, neti_stack_apply_create);
mutex_enter(&nts->nts_lock);
nts->nts_flags &= ~NSF_ZONE_CREATE;
mutex_exit(&nts->nts_lock);
mutex_exit(&neti_stack_lock);
return (nts);
}
/*
* Run the shutdown for all of the hooks.
*/
/*ARGSUSED*/
static void
neti_stack_shutdown(netstackid_t stackid, void *arg)
{
neti_stack_t *nts = arg;
net_instance_int_t *n;
struct net_data *nd;
ASSERT(nts != NULL);
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
/*
* Walk through all of the protocol stacks and mark them as shutting
* down.
*/
LIST_FOREACH(nd, &nts->nts_netd_head, netd_list) {
nd->netd_condemned = 1;
}
/*
* Now proceed to see which callbacks are waiting to hear about the
* impending shutdown...
*/
LIST_FOREACH(n, &nts->nts_instances, nini_next) {
if (n->nini_instance->nin_shutdown == NULL) {
/*
* If there is no shutdown function registered,
* fake that we have completed it.
*/
n->nini_flags |= NSS_SHUTDOWN_COMPLETED;
continue;
}
/*
* We need to ensure that we don't try and shutdown something
* that is already in the process of being shutdown or
* destroyed. If it is still being created, that's ok, the
* shtudown flag is added to the mix of things to do.
*/
if ((n->nini_flags & (NSS_DESTROY_ALL|NSS_SHUTDOWN_ALL)) == 0)
n->nini_flags |= NSS_SHUTDOWN_NEEDED;
}
nts->nts_flags |= NSF_ZONE_SHUTDOWN;
mutex_exit(&nts->nts_lock);
neti_apply_all_instances(nts, neti_stack_apply_shutdown);
mutex_enter(&nts->nts_lock);
nts->nts_netstack = NULL;
nts->nts_flags &= ~NSF_ZONE_SHUTDOWN;
mutex_exit(&nts->nts_lock);
mutex_exit(&neti_stack_lock);
ASSERT(nts != NULL);
}
/*
* Free the neti stack instance.
* This function relies on the netstack framework only calling the _destroy
* callback once for each stackid. The netstack framework also provides us
* with assurance that nobody else will be doing any work (_create, _shutdown)
* on it, so there is no need to set and use flags to guard against
* simultaneous execution (ie. no need to set NSF_CLOSING.)
* What is required, however, is to make sure that we don't corrupt the
* list of neti_stack_t's for other code that walks it.
*/
/*ARGSUSED*/
static void
neti_stack_fini(netstackid_t stackid, void *arg)
{
neti_stack_t *nts = arg;
net_instance_int_t *n;
struct net_data *nd;
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
LIST_REMOVE(nts, nts_next);
/*
* Walk through all of the protocol stacks and mark them as being
* destroyed.
*/
LIST_FOREACH(nd, &nts->nts_netd_head, netd_list) {
nd->netd_condemned = 2;
}
LIST_FOREACH(n, &nts->nts_instances, nini_next) {
ASSERT((n->nini_flags & NSS_SHUTDOWN_ALL) != 0);
if ((n->nini_flags & NSS_DESTROY_ALL) == 0)
n->nini_flags |= NSS_DESTROY_NEEDED;
}
mutex_exit(&nts->nts_lock);
neti_apply_all_instances(nts, neti_stack_apply_destroy);
while (!LIST_EMPTY(&nts->nts_instances)) {
n = LIST_FIRST(&nts->nts_instances);
LIST_REMOVE(n, nini_next);
net_instance_int_free(n);
}
mutex_exit(&neti_stack_lock);
ASSERT(LIST_EMPTY(&nts->nts_netd_head));
mutex_destroy(&nts->nts_lock);
cv_destroy(&nts->nts_cv);
kmem_free(nts, sizeof (*nts));
}
static net_instance_int_t *
net_instance_int_create(net_instance_t *nin, net_instance_int_t *parent)
{
net_instance_int_t *nini;
nini = kmem_zalloc(sizeof (net_instance_int_t), KM_SLEEP);
nini->nini_instance = nin;
nini->nini_parent = parent;
if (parent != NULL) {
/*
* If the parent pointer is non-NULL then we take that as
* an indication that the net_instance_int_t is being
* created for an active instance and there will expect
* the create function to be called. In contrast, if
* parent is NULL then this code assumes the object is
* being prepared for insertion onto the master list of
* callbacks to be called when an instance is created, etc.
*/
parent->nini_ref++;
nini->nini_flags |= NSS_CREATE_NEEDED;
}
cv_init(&nini->nini_cv, NULL, CV_DRIVER, NULL);
return (nini);
}
/*
* Free'ing of a net_instance_int_t is only to be done when we know nobody
* else has is using it. For both parents and clones, this is indicated by
* nini_ref being greater than 0, however, nini_ref is managed differently
* for its two uses. For parents, nini_ref is increased when a new clone is
* created and it is decremented here. For clones, nini_ref is adjusted by
* code elsewhere (e.g. in neti_stack_apply_*) and is not changed here.
*/
static void
net_instance_int_free(net_instance_int_t *nini)
{
/*
* This mutex guards the use of nini_ref.
*/
ASSERT(mutex_owned(&neti_stack_lock));
/*
* For 'parent' structures, nini_ref will drop to 0 when
* the last clone has been free'd... but for clones, it
* is possible for nini_ref to be non-zero if we get in
* here when all the locks have been given up to execute
* a callback or wait_for_nini_inprogress. In that case,
* we do not want to free the structure and just indicate
* that it is on the "doomed" list, thus we set the
* condemned flag.
*/
if (nini->nini_parent != NULL) {
if (nini->nini_ref > 0)
nini->nini_condemned = B_TRUE;
nini->nini_parent->nini_ref--;
if (nini->nini_parent->nini_ref == 0)
net_instance_int_free(nini->nini_parent);
nini->nini_parent = NULL;
}
if (nini->nini_ref == 0) {
cv_destroy(&nini->nini_cv);
kmem_free(nini, sizeof (*nini));
}
}
net_instance_t *
net_instance_alloc(const int version)
{
net_instance_t *nin;
if (version != NETINFO_VERSION)
return (NULL);
nin = kmem_zalloc(sizeof (net_instance_t), KM_SLEEP);
nin->nin_version = version;
return (nin);
}
void
net_instance_free(net_instance_t *nin)
{
kmem_free(nin, sizeof (*nin));
}
int
net_instance_register(net_instance_t *nin)
{
net_instance_int_t *parent;
net_instance_int_t *tmp;
neti_stack_t *nts;
ASSERT(nin->nin_name != NULL);
if (nin->nin_create == NULL || nin->nin_destroy == NULL)
return (DDI_FAILURE);
mutex_enter(&neti_stack_lock);
/*
* Search for duplicate, either on the global list or on any
* of the known instances.
*/
LIST_FOREACH(tmp, &neti_instance_list, nini_next) {
if (strcmp(nin->nin_name, tmp->nini_instance->nin_name) == 0) {
mutex_exit(&neti_stack_lock);
return (DDI_FAILURE);
}
}
/*
* Now insert and activate.
*/
parent = net_instance_int_create(nin, NULL);
ASSERT(parent != NULL);
LIST_INSERT_HEAD(&neti_instance_list, parent, nini_next);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
mutex_enter(&nts->nts_lock);
/*
* If shutdown of the zone has begun then do not add a new
* instance of the object being registered.
*/
if ((nts->nts_flags & NSF_ZONE_SHUTDOWN) ||
(nts->nts_netstack == NULL)) {
mutex_exit(&nts->nts_lock);
continue;
}
/*
* This function returns with the NSS_CREATE_NEEDED flag
* set in "dup", so it is adequately prepared for the
* upcoming apply.
*/
tmp = net_instance_int_create(nin, parent);
ASSERT(tmp != NULL);
LIST_INSERT_HEAD(&nts->nts_instances, tmp, nini_next);
mutex_exit(&nts->nts_lock);
}
neti_apply_all_stacks(parent, neti_stack_apply_create);
mutex_exit(&neti_stack_lock);
return (DDI_SUCCESS);
}
/*
* While net_instance_register() isn't likely to be racing against itself,
* net_instance_unregister() can be entered from various directions that
* can compete: shutdown of a zone, unloading of a module (and it calling
* _unregister() as part of that) and the module doing an _unregister()
* anyway.
*/
int
net_instance_unregister(net_instance_t *nin)
{
net_instance_int_t *parent;
net_instance_int_t *tmp;
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(tmp, &neti_instance_list, nini_next) {
if (strcmp(tmp->nini_instance->nin_name, nin->nin_name) == 0) {
LIST_REMOVE(tmp, nini_next);
break;
}
}
if (tmp == NULL) {
mutex_exit(&neti_stack_lock);
return (DDI_FAILURE);
}
parent = tmp;
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
mutex_enter(&nts->nts_lock);
LIST_FOREACH(tmp, &nts->nts_instances, nini_next) {
if (tmp->nini_parent != parent)
continue;
/*
* Netstack difference:
* In netstack.c, there is a check for
* NSS_CREATE_COMPLETED before setting the other
* _NEEDED flags. If we consider that a list
* member must always have at least the _CREATE_NEEDED
* flag set and that wait_for_nini_inprogress will
* also wait for that flag to be cleared in both of
* the shutdown and destroy apply functions.
*
* It is possible to optimize out the case where
* all three _NEEDED flags are set to being able
* to pretend everything has been done and just
* set all three _COMPLETE flags. This makes a
* special case that we then need to consider in
* other locations, so for the sake of simplicity,
* we leave it as it is.
*/
if ((tmp->nini_flags & NSS_SHUTDOWN_ALL) == 0)
tmp->nini_flags |= NSS_SHUTDOWN_NEEDED;
if ((tmp->nini_flags & NSS_DESTROY_ALL) == 0)
tmp->nini_flags |= NSS_DESTROY_NEEDED;
break;
}
mutex_exit(&nts->nts_lock);
}
/*
* Each of these functions ensures that the requisite _COMPLETED
* flag is present before calling the apply function. So we are
* guaranteed to have NSS_CREATE_COMPLETED|NSS_SHUTDOWN_COMPLETED
* both set after the first call here and when the second completes,
* NSS_DESTROY_COMPLETED is also set.
*/
neti_apply_all_stacks(parent, neti_stack_apply_shutdown);
neti_apply_all_stacks(parent, neti_stack_apply_destroy);
/*
* Remove the instance callback information from each stack.
*/
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
mutex_enter(&nts->nts_lock);
LIST_FOREACH(tmp, &nts->nts_instances, nini_next) {
if ((tmp->nini_parent == parent) &&
(tmp->nini_flags & NSS_SHUTDOWN_COMPLETED) &&
(tmp->nini_flags & NSS_DESTROY_COMPLETED)) {
/*
* There should only be one entry that has a
* matching nini_parent so there is no need to
* worry about continuing a loop where we are
* free'ing the structure holding the 'next'
* pointer.
*/
LIST_REMOVE(tmp, nini_next);
net_instance_int_free(tmp);
break;
}
}
mutex_exit(&nts->nts_lock);
}
mutex_exit(&neti_stack_lock);
return (DDI_SUCCESS);
}
static void
neti_apply_all_instances(neti_stack_t *nts, napplyfn_t *applyfn)
{
net_instance_int_t *n;
ASSERT(mutex_owned(&neti_stack_lock));
n = LIST_FIRST(&nts->nts_instances);
while (n != NULL) {
if ((applyfn)(nts, n->nini_parent)) {
/* Lock dropped - restart at head */
n = LIST_FIRST(&nts->nts_instances);
} else {
n = LIST_NEXT(n, nini_next);
}
}
}
static void
neti_apply_all_stacks(void *parent, napplyfn_t *applyfn)
{
neti_stack_t *nts;
ASSERT(mutex_owned(&neti_stack_lock));
nts = LIST_FIRST(&neti_stack_list);
while (nts != NULL) {
/*
* This function differs, in that it doesn't have a call to
* a "wait_creator" call, from the zsd/netstack code. The
* waiting is pushed into the apply functions which cause
* the waiting to be done in wait_for_nini_progress with
* the passing in of cmask.
*/
if ((applyfn)(nts, parent)) {
/* Lock dropped - restart at head */
nts = LIST_FIRST(&neti_stack_list);
} else {
nts = LIST_NEXT(nts, nts_next);
}
}
}
static boolean_t
neti_stack_apply_create(neti_stack_t *nts, void *parent)
{
void *result;
boolean_t dropped = B_FALSE;
net_instance_int_t *tmp;
net_instance_t *nin;
ASSERT(parent != NULL);
ASSERT(mutex_owned(&neti_stack_lock));
mutex_enter(&nts->nts_lock);
LIST_FOREACH(tmp, &nts->nts_instances, nini_next) {
if (tmp->nini_parent == parent)
break;
}
if (tmp == NULL) {
mutex_exit(&nts->nts_lock);
return (dropped);
}
tmp->nini_ref++;
if (wait_for_nini_inprogress(nts, tmp, 0))
dropped = B_TRUE;
if ((tmp->nini_flags & NSS_CREATE_NEEDED) && !tmp->nini_condemned) {
nin = tmp->nini_instance;
tmp->nini_flags &= ~NSS_CREATE_NEEDED;
tmp->nini_flags |= NSS_CREATE_INPROGRESS;
DTRACE_PROBE2(neti__stack__create__inprogress,
neti_stack_t *, nts, net_instance_int_t *, tmp);
mutex_exit(&nts->nts_lock);
mutex_exit(&neti_stack_lock);
dropped = B_TRUE;
ASSERT(tmp->nini_created == NULL);
ASSERT(nin->nin_create != NULL);
DTRACE_PROBE2(neti__stack__create__start,
netstackid_t, nts->nts_id,
neti_stack_t *, nts);
result = (nin->nin_create)(nts->nts_id);
DTRACE_PROBE2(neti__stack__create__end,
void *, result, neti_stack_t *, nts);
ASSERT(result != NULL);
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
tmp->nini_created = result;
tmp->nini_flags &= ~NSS_CREATE_INPROGRESS;
tmp->nini_flags |= NSS_CREATE_COMPLETED;
cv_broadcast(&tmp->nini_cv);
DTRACE_PROBE2(neti__stack__create__completed,
neti_stack_t *, nts, net_instance_int_t *, tmp);
}
tmp->nini_ref--;
if (tmp->nini_condemned) {
net_instance_int_free(tmp);
dropped = B_TRUE;
}
mutex_exit(&nts->nts_lock);
return (dropped);
}
static boolean_t
neti_stack_apply_shutdown(neti_stack_t *nts, void *parent)
{
boolean_t dropped = B_FALSE;
net_instance_int_t *tmp;
net_instance_t *nin;
ASSERT(parent != NULL);
ASSERT(mutex_owned(&neti_stack_lock));
mutex_enter(&nts->nts_lock);
LIST_FOREACH(tmp, &nts->nts_instances, nini_next) {
if (tmp->nini_parent == parent)
break;
}
if (tmp == NULL) {
mutex_exit(&nts->nts_lock);
return (dropped);
}
ASSERT((tmp->nini_flags & NSS_SHUTDOWN_ALL) != 0);
tmp->nini_ref++;
if (wait_for_nini_inprogress(nts, tmp, NSS_CREATE_NEEDED))
dropped = B_TRUE;
nin = tmp->nini_instance;
if (nin->nin_shutdown == NULL) {
/*
* If there is no shutdown function, fake having completed it.
*/
if (tmp->nini_flags & NSS_SHUTDOWN_NEEDED) {
tmp->nini_flags &= ~NSS_SHUTDOWN_NEEDED;
tmp->nini_flags |= NSS_SHUTDOWN_COMPLETED;
}
tmp->nini_ref--;
if (tmp->nini_condemned) {
net_instance_int_free(tmp);
dropped = B_TRUE;
}
mutex_exit(&nts->nts_lock);
return (dropped);
}
if ((tmp->nini_flags & NSS_SHUTDOWN_NEEDED) && !tmp->nini_condemned) {
ASSERT((tmp->nini_flags & NSS_CREATE_COMPLETED) != 0);
tmp->nini_flags &= ~NSS_SHUTDOWN_NEEDED;
tmp->nini_flags |= NSS_SHUTDOWN_INPROGRESS;
DTRACE_PROBE2(neti__stack__shutdown__inprogress,
neti_stack_t *, nts, net_instance_int_t *, tmp);
mutex_exit(&nts->nts_lock);
mutex_exit(&neti_stack_lock);
dropped = B_TRUE;
ASSERT(nin->nin_shutdown != NULL);
DTRACE_PROBE2(neti__stack__shutdown__start,
netstackid_t, nts->nts_id,
neti_stack_t *, nts);
(nin->nin_shutdown)(nts->nts_id, tmp->nini_created);
DTRACE_PROBE1(neti__stack__shutdown__end,
neti_stack_t *, nts);
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
tmp->nini_flags &= ~NSS_SHUTDOWN_INPROGRESS;
tmp->nini_flags |= NSS_SHUTDOWN_COMPLETED;
cv_broadcast(&tmp->nini_cv);
DTRACE_PROBE2(neti__stack__shutdown__completed,
neti_stack_t *, nts, net_instance_int_t *, tmp);
}
ASSERT((tmp->nini_flags & NSS_SHUTDOWN_COMPLETED) != 0);
tmp->nini_ref--;
if (tmp->nini_condemned) {
net_instance_int_free(tmp);
dropped = B_TRUE;
}
mutex_exit(&nts->nts_lock);
return (dropped);
}
static boolean_t
neti_stack_apply_destroy(neti_stack_t *nts, void *parent)
{
boolean_t dropped = B_FALSE;
net_instance_int_t *tmp;
net_instance_t *nin;
ASSERT(parent != NULL);
ASSERT(mutex_owned(&neti_stack_lock));
mutex_enter(&nts->nts_lock);
LIST_FOREACH(tmp, &nts->nts_instances, nini_next) {
if (tmp->nini_parent == parent)
break;
}
if (tmp == NULL) {
mutex_exit(&nts->nts_lock);
return (dropped);
}
tmp->nini_ref++;
/*
* We pause here so that when we continue we know that we're the
* only one doing anything active with this node.
*/
if (wait_for_nini_inprogress(nts, tmp,
NSS_CREATE_NEEDED|NSS_SHUTDOWN_NEEDED))
dropped = B_TRUE;
if ((tmp->nini_flags & NSS_DESTROY_NEEDED) && !tmp->nini_condemned) {
ASSERT((tmp->nini_flags & NSS_SHUTDOWN_COMPLETED) != 0);
nin = tmp->nini_instance;
tmp->nini_flags &= ~NSS_DESTROY_NEEDED;
tmp->nini_flags |= NSS_DESTROY_INPROGRESS;
DTRACE_PROBE2(neti__stack__destroy__inprogress,
neti_stack_t *, nts, net_instance_int_t *, tmp);
mutex_exit(&nts->nts_lock);
mutex_exit(&neti_stack_lock);
dropped = B_TRUE;
ASSERT(nin->nin_destroy != NULL);
DTRACE_PROBE2(neti__stack__destroy__start,
netstackid_t, nts->nts_id,
neti_stack_t *, nts);
(nin->nin_destroy)(nts->nts_id, tmp->nini_created);
DTRACE_PROBE1(neti__stack__destroy__end,
neti_stack_t *, nts);
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
tmp->nini_flags &= ~NSS_DESTROY_INPROGRESS;
tmp->nini_flags |= NSS_DESTROY_COMPLETED;
cv_broadcast(&tmp->nini_cv);
DTRACE_PROBE2(neti__stack__destroy__completed,
neti_stack_t *, nts, net_instance_int_t *, tmp);
}
tmp->nini_ref--;
if (tmp->nini_condemned) {
net_instance_int_free(tmp);
dropped = B_TRUE;
}
mutex_exit(&nts->nts_lock);
return (dropped);
}
static boolean_t
wait_for_nini_inprogress(neti_stack_t *nts, net_instance_int_t *nini,
uint32_t cmask)
{
boolean_t dropped = B_FALSE;
ASSERT(mutex_owned(&neti_stack_lock));
while (nini->nini_flags & (NSS_ALL_INPROGRESS|cmask)) {
DTRACE_PROBE2(neti__wait__nini__inprogress,
neti_stack_t *, nts, net_instance_int_t *, nini);
dropped = B_TRUE;
mutex_exit(&neti_stack_lock);
cv_wait(&nini->nini_cv, &nts->nts_lock);
/* First drop netstack_lock to preserve order */
mutex_exit(&nts->nts_lock);
DTRACE_PROBE2(wait__nini__inprogress__pause,
neti_stack_t *, nts, net_instance_int_t *, nini);
mutex_enter(&neti_stack_lock);
mutex_enter(&nts->nts_lock);
}
DTRACE_PROBE2(neti__wait__nini__inprogress__complete,
neti_stack_t *, nts, net_instance_int_t *, nini);
return (dropped);
}
/* ======================================================================= */
netid_t
net_zoneidtonetid(zoneid_t zoneid)
{
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
if (nts->nts_zoneid == zoneid) {
mutex_exit(&neti_stack_lock);
return (nts->nts_id);
}
}
mutex_exit(&neti_stack_lock);
return (-1);
}
zoneid_t
net_getzoneidbynetid(netid_t netid)
{
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
if (nts->nts_id == netid) {
mutex_exit(&neti_stack_lock);
return (nts->nts_zoneid);
}
}
mutex_exit(&neti_stack_lock);
return (-1);
}
netstackid_t
net_getnetstackidbynetid(netid_t netid)
{
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
if (nts->nts_id == netid) {
mutex_exit(&neti_stack_lock);
return (nts->nts_stackid);
}
}
mutex_exit(&neti_stack_lock);
return (-1);
}
netid_t
net_getnetidbynetstackid(netstackid_t netstackid)
{
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
if (nts->nts_stackid == netstackid) {
mutex_exit(&neti_stack_lock);
return (nts->nts_id);
}
}
mutex_exit(&neti_stack_lock);
return (-1);
}
neti_stack_t *
net_getnetistackbyid(netid_t netid)
{
neti_stack_t *nts;
mutex_enter(&neti_stack_lock);
LIST_FOREACH(nts, &neti_stack_list, nts_next) {
if (nts->nts_id == netid) {
mutex_exit(&neti_stack_lock);
return (nts);
}
}
mutex_exit(&neti_stack_lock);
return (NULL);
}
int
net_instance_notify_register(netid_t netid, hook_notify_fn_t callback,
void *arg)
{
return (hook_stack_notify_register(net_getnetstackidbynetid(netid),
callback, arg));
}
int
net_instance_notify_unregister(netid_t netid, hook_notify_fn_t callback)
{
return (hook_stack_notify_unregister(net_getnetstackidbynetid(netid),
callback));
}