common/io/neti_impl.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 <inet/common.h>
#include <inet/led.h>
#include <inet/ip.h>
#include <sys/neti.h>
#include <sys/zone.h>

static net_handle_t net_find(const char *protocol, neti_stack_t *ns);

static net_handle_t
net_find(const char *protocol, neti_stack_t *nts)
{
	struct net_data *n;

	ASSERT(protocol != NULL);
	ASSERT(nts != NULL);

	LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
		ASSERT(n->netd_info.netp_name != NULL);
		/*
		 * If they're trying to find a protocol that is being
		 * shutdown, just ignore it..
		 */
		if (n->netd_condemned != 0)
			continue;
		if (strcmp(n->netd_info.netp_name, protocol) == 0) {
			break;
		}
	}

	return (n);
}

net_handle_t
net_protocol_register(netid_t id, const net_protocol_t *info)
{
	struct net_data *n, *new;
	neti_stack_t *nts;

	ASSERT(info != NULL);

	nts = net_getnetistackbyid(id);
	if (nts == NULL)
		return (NULL);

	new = kmem_alloc(sizeof (*new), KM_SLEEP);
	new->netd_refcnt = 1;
	new->netd_hooks = NULL;
	new->netd_info = *info;
	new->netd_stack = nts;
	new->netd_condemned = 0;

	mutex_enter(&nts->nts_lock);
	n = net_find(info->netp_name, nts);
	if (n != NULL) {
		mutex_exit(&nts->nts_lock);
		kmem_free(new, sizeof (*new));
		return (NULL);
	}

	if (LIST_EMPTY(&nts->nts_netd_head)) {
		LIST_INSERT_HEAD(&nts->nts_netd_head, new, netd_list);
	} else {
		LIST_INSERT_AFTER(LIST_FIRST(&nts->nts_netd_head),
		    new, netd_list);
	}
	mutex_exit(&nts->nts_lock);

	return (new);
}

int
net_protocol_unregister(net_handle_t info)
{
	neti_stack_t *nts;

	ASSERT(info != NULL);

	nts = info->netd_stack;
	ASSERT(nts != NULL);

	mutex_enter(&nts->nts_lock);
	LIST_REMOVE(info, netd_list);
	info->netd_stack = NULL;
	mutex_exit(&nts->nts_lock);

	(void) net_protocol_release(info);

	return (0);
}

net_handle_t
net_protocol_lookup(netid_t netid, const char *protocol)
{
	neti_stack_t *nts;
	net_handle_t nd;

	ASSERT(protocol != NULL);

	nts = net_getnetistackbyid(netid);
	if (nts == NULL)
		return (NULL);

	mutex_enter(&nts->nts_lock);
	nd = net_find(protocol, nts);
	if (nd != NULL)
		atomic_inc_32((uint_t *)&nd->netd_refcnt);
	mutex_exit(&nts->nts_lock);
	return (nd);
}

/*
 * Note: the man page specifies "returns -1 if the value passed in is unknown
 * to this framework".  We are not doing a lookup in this function, just a
 * simply add to the netd_refcnt of the net_handle_t passed in, so -1 is never a
 * return value.
 */
int
net_protocol_release(net_handle_t info)
{

	ASSERT(info->netd_refcnt > 0);
	/*
	 * Is this safe? No hold on nts_lock? Consider that if the caller
	 * of net_protocol_release() is going to free this structure then
	 * it is now the only owner (refcnt==1) and it will have been
	 * removed from the nts_netd_head list on the neti_stack_t from a
	 * call to net_protocol_unregister already, so it is thus an orphan.
	 */
	if (atomic_dec_32_nv((uint_t *)&info->netd_refcnt) == 0) {
		ASSERT(info->netd_hooks == NULL);
		ASSERT(info->netd_stack == NULL);
		kmem_free(info, sizeof (struct net_data));
	}

	return (0);
}

net_handle_t
net_protocol_walk(netid_t netid, net_handle_t info)
{
	struct net_data *n = NULL;
	boolean_t found = B_FALSE;
	neti_stack_t *nts;

	nts = net_getnetistackbyid(netid);
	ASSERT(nts != NULL);

	if (info == NULL)
		found = B_TRUE;

	mutex_enter(&nts->nts_lock);
	LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
		if (found) {
			/*
			 * We are only interested in finding protocols that
			 * are not in some sort of shutdown state.  There is
			 * no need to check for netd_stack==NULL because
			 * that implies it is no longer on this list.
			 */
			if (n->netd_condemned == 0)
				continue;
			break;
		}

		if (n == info)
			found = B_TRUE;
	}

	if (info != NULL)
		(void) net_protocol_release(info);

	if (n != NULL)
		atomic_inc_32((uint_t *)&n->netd_refcnt);

	mutex_exit(&nts->nts_lock);

	return (n);
}

/*
 * Public accessor functions
 */
int
net_getifname(net_handle_t info, phy_if_t nic, char *buffer,
    const size_t buflen)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_getifname(info, nic, buffer, buflen));
}

int
net_getmtu(net_handle_t info, phy_if_t nic, lif_if_t ifdata)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_getmtu(info, nic, ifdata));
}

int
net_getpmtuenabled(net_handle_t info)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_getpmtuenabled(info));
}

int
net_getlifaddr(net_handle_t info, phy_if_t nic, lif_if_t ifdata,
    int nelem, net_ifaddr_t type[], void *storage)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_getlifaddr(info, nic, ifdata,
	    nelem, type, storage));
}

int
net_getlifzone(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
    zoneid_t *zoneid)
{
	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.neti_getlifzone(info, phy_ifdata, ifdata,
	    zoneid));
}

int
net_getlifflags(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
    uint64_t *flags)
{
	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.neti_getlifflags(info, phy_ifdata, ifdata,
	    flags));
}

phy_if_t
net_phygetnext(net_handle_t info, phy_if_t nic)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return ((phy_if_t)-1);

	return (info->netd_info.netp_phygetnext(info, nic));
}

phy_if_t
net_phylookup(net_handle_t info, const char *name)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return ((phy_if_t)-1);

	return (info->netd_info.netp_phylookup(info, name));
}

lif_if_t
net_lifgetnext(net_handle_t info, phy_if_t ifidx, lif_if_t ifdata)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return ((lif_if_t)-1);

	return (info->netd_info.netp_lifgetnext(info, ifidx, ifdata));
}

int
net_inject(net_handle_t info, inject_t style, net_inject_t *packet)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_inject(info, style, packet));
}

phy_if_t
net_routeto(net_handle_t info, struct sockaddr *address, struct sockaddr *next)
{

	ASSERT(info != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return ((phy_if_t)-1);

	return (info->netd_info.netp_routeto(info, address, next));
}

int
net_ispartialchecksum(net_handle_t info, mblk_t *mp)
{

	ASSERT(info != NULL);
	ASSERT(mp != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_ispartialchecksum(info, mp));
}

int
net_isvalidchecksum(net_handle_t info, mblk_t *mp)
{

	ASSERT(info != NULL);
	ASSERT(mp != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (-1);

	return (info->netd_info.netp_isvalidchecksum(info, mp));
}

/*
 * Hooks related functions
 */

/*
 * Function:	net_family_register
 * Returns:	int - 0 = Succ, Else = Fail
 * Parameters:	info(I) - protocol
 *		hf(I) - family pointer
 *
 * Call hook_family_add to register family
 *
 * There is no need to bump netd_refcnt in the two functions
 * net_family_register and net_family_unregister because the caller of these
 * two functions is assumed to "own" a reference on 'info' via an earlier
 * call to net_protocol_register().  Thus the owner is expected to do a
 * call to net_protocol_unregister() after having done a
 * net_family_unregister() to make sure things are properly cleaned up.
 * Passing a pointer to info->netd_hooks into hook_family_add is required
 * so that this can be set before the notify functions are called. If this
 * does not happen, the notify function may do something that seems fine,
 * like add a notify function to the family but cause a panic because
 * netd_hooks is NULL when we get to hook_family_notify_register.
 */
int
net_family_register(net_handle_t info, hook_family_t *hf)
{
	netstack_t *ns;

	ASSERT(info != NULL);
	ASSERT(hf != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (ESHUTDOWN);

	if (info->netd_hooks != NULL)
		return (EEXIST);

	ns = info->netd_stack->nts_netstack;
	ASSERT(ns != NULL);
	if (hook_family_add(hf, ns->netstack_hook,
	    (void **)&info->netd_hooks) == NULL)
		return (EEXIST);

	return (0);
}

/*
 * Function:	net_family_unregister
 * Returns:	int - transparent value, explained by caller
 * Parameters:	info(I) - protocol
 *		hf(I) - family pointer
 *
 * Call hook_family_remove to unregister family
 */
int
net_family_unregister(net_handle_t info, hook_family_t *hf)
{
	int ret;

	ASSERT(info != NULL);
	ASSERT(hf != NULL);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	if (strcmp(info->netd_hooks->hfi_family.hf_name,
	    hf->hf_name) != 0)
		return (EINVAL);

	ret = hook_family_remove(info->netd_hooks);
	if (ret == 0)
		info->netd_hooks = NULL;

	return (ret);
}

int
net_family_shutdown(net_handle_t info, hook_family_t *hf)
{

	ASSERT(info != NULL);
	ASSERT(hf != NULL);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	if (strcmp(info->netd_hooks->hfi_family.hf_name,
	    hf->hf_name) != 0)
		return (EINVAL);

	return (hook_family_shutdown(info->netd_hooks));
}

/*
 * Function:	net_event_register
 * Returns:	internal event pointer - NULL = Fail
 * Parameters:	info(I) - protocol
 *		he(I) - event pointer
 *
 * Call hook_event_add to register event on specific family
 * 	Internal event pointer is returned so caller can get
 * 	handle to run hooks
 */
hook_event_token_t
net_event_register(net_handle_t info, hook_event_t *he)
{
	hook_event_int_t *hei;

	ASSERT(info != NULL);
	ASSERT(he != NULL);

	if (info->netd_hooks == NULL || info->netd_condemned != 0 ||
	    info->netd_stack == NULL)
		return (NULL);

	hei = hook_event_add(info->netd_hooks, he);
	return ((hook_event_token_t)hei);
}

/*
 * Function:	net_event_unregister
 * Returns:	int - transparent value, explained by caller
 * Parameters:	info(I) - protocol
 *		he(I) - event pointer
 *
 * Call hook_event_remove to unregister event on specific family
 */
int
net_event_unregister(net_handle_t info, hook_event_t *he)
{

	ASSERT(info != NULL);
	ASSERT(he != NULL);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	return (hook_event_remove(info->netd_hooks, he));
}

int
net_event_shutdown(net_handle_t info, hook_event_t *he)
{

	ASSERT(info != NULL);
	ASSERT(he != NULL);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	return (hook_event_shutdown(info->netd_hooks, he));
}

/*
 * Function:	net_hook_register
 * Returns:	int - transparent value, explained by caller
 * Parameters:	info(I) - protocol
 *		event(I) - event name
 *		h(I) - hook pointer
 *
 * Call hook_register to add hook on specific family/event
 */
int
net_hook_register(net_handle_t info, char *event, hook_t *h)
{

	ASSERT(info != NULL);
	ASSERT(event != NULL);
	ASSERT(h != NULL);

	if (info->netd_condemned != 0 || info->netd_stack == NULL)
		return (ESHUTDOWN);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	return (hook_register(info->netd_hooks, event, h));
}

/*
 * Function:	net_hook_unregister
 * Returns:	int - transparent value, explained by caller
 * Parameters:	info(I) - protocol
 *		event(I) - event name
 *		h(I) - hook pointer
 *
 * Call hook_unregister to remove hook on specific family/event
 */
int
net_hook_unregister(net_handle_t info, char *event, hook_t *h)
{

	ASSERT(info != NULL);
	ASSERT(event != NULL);
	ASSERT(h != NULL);

	if (info->netd_hooks == NULL)
		return (ENXIO);

	return (hook_unregister(info->netd_hooks, event, h));
}

netid_t
net_getnetid(net_handle_t netd)
{

	if (netd->netd_stack == NULL)
		return (-1);
	return (netd->netd_stack->nts_id);
}

net_inject_t *
net_inject_alloc(const int version)
{
	net_inject_t *ni;

	ni = kmem_zalloc(sizeof (*ni), KM_NOSLEEP);
	if (ni == NULL)
		return (NULL);

	ni->ni_version = version;
	return (ni);
}

void
net_inject_free(net_inject_t *ni)
{
	kmem_free(ni, sizeof (*ni));
}

kstat_t *
net_kstat_create(netid_t netid, char *module, int instance, char *name,
    char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag)
{
	netstackid_t stackid = net_getnetstackidbynetid(netid);

	if (stackid == -1)
		return (NULL);

	return (kstat_create_netstack(module, instance, name, class, type,
	    ndata, ks_flag, stackid));
}

void
net_kstat_delete(netid_t netid, kstat_t *ks)
{
	netstackid_t stackid = net_getnetstackidbynetid(netid);

	if (stackid != -1)
		kstat_delete_netstack(ks, stackid);
}

int
net_event_notify_register(net_handle_t family, char *event,
    hook_notify_fn_t callback, void *arg)
{
	int error;

	if (family->netd_condemned != 0 || family->netd_stack == NULL)
		return (ESHUTDOWN);

	error = hook_event_notify_register(family->netd_hooks, event,
	    callback, arg);

	return (error);
}

int
net_event_notify_unregister(net_handle_t family, char *event,
    hook_notify_fn_t callback)
{
	int error;

	error = hook_event_notify_unregister(family->netd_hooks, event,
	    callback);

	return (error);
}

int
net_protocol_notify_register(net_handle_t family, hook_notify_fn_t callback,
    void *arg)
{
	int error;

	if (family->netd_condemned != 0 || family->netd_stack == NULL)
		return (ESHUTDOWN);

	error = hook_family_notify_register(family->netd_hooks, callback,
	    arg);

	return (error);
}

int
net_protocol_notify_unregister(net_handle_t family, hook_notify_fn_t callback)
{
	int error;

	error = hook_family_notify_unregister(family->netd_hooks, callback);

	return (error);
}