mac_provider.c revision ae6aa22afeb444ae208c287e7227a4a7c877f17a
/*
* 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
* 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.
*/
#include <sys/id_space.h>
#include <sys/mac_provider.h>
#include <sys/mac_impl.h>
#include <sys/mac_client_impl.h>
#include <sys/mac_client_priv.h>
#include <sys/mac_soft_ring.h>
#include <sys/mac_flow.h>
#include <sys/ddi_intr_impl.h>
/*
* MAC Provider Interface.
*
* Interface for GLDv3 compatible NIC drivers.
*/
static void i_mac_notify_thread(void *);
typedef void (*mac_notify_default_cb_fn_t)(mac_impl_t *);
typedef struct mac_notify_default_cb_s {
{ MAC_NOTE_PROMISC, NULL},
{ MAC_NOTE_UNICST, NULL},
{ MAC_NOTE_TX, NULL},
{ MAC_NOTE_RESOURCE, NULL},
{ MAC_NOTE_DEVPROMISC, NULL},
{ MAC_NOTE_SDU_SIZE, NULL},
{ MAC_NOTE_MARGIN, NULL},
{ MAC_NOTE_CAPAB_CHG, NULL},
};
/*
* Driver support functions.
*/
/* REGISTRATION */
{
/*
* Make sure there isn't a version mismatch between the driver and
* the framework. In the future, if multiple versions are
* supported, this check could become more sophisticated.
*/
if (mac_version != MAC_VERSION)
return (NULL);
return (mregp);
}
void
{
}
/*
* mac_register() is how drivers register new MACs with the GLDv3
* framework. The mregp argument is allocated by drivers using the
* mac_alloc() function, and can be freed using mac_free() immediately upon
* return from mac_register(). Upon success (0 return value), the mhp
* opaque pointer becomes the driver's handle to its MAC interface, and is
* the argument to all other mac module entry points.
*/
/* ARGSUSED */
int
{
char *driver;
/* Find the required MAC-Type plugin. */
return (EINVAL);
/* Create a mac_impl_t to represent this MAC. */
/*
* The mac is not ready for open yet.
*/
/*
* When a mac is registered, the m_instance field can be set to:
*
* 0: Get the mac's instance number from m_dip.
* This is usually used for physical device dips.
*
* [1 .. MAC_MAX_MINOR-1]: Use the value as the mac's instance number.
* For example, when an aggregation is created with the key option,
* "key" will be used as the instance number.
*
* -1: Assign an instance number from [MAC_MAX_MINOR .. MAXMIN-1].
* This is often used when a MAC of a virtual link is registered
* (e.g., aggregation when "key" is not specified, or vnic).
*
* Note that the instance number is used to derive the mi_minor field
* of mac_impl_t, which will then be used to derive the name of kstats
* and the devfs nodes. The first 2 cases are needed to preserve
* backward compatibility.
*/
switch (mregp->m_instance) {
case 0:
break;
case ((uint_t)-1):
if (minor == 0) {
goto fail;
}
break;
default:
if (instance >= MAC_MAX_MINOR) {
goto fail;
}
break;
}
mip->mi_nclients = 0;
/* Construct the MAC name as <drvname><instance> */
goto fail;
/*
* If the media supports a broadcast address, cache a pointer to it
* in the mac_info_t so that upper layers can use it.
*/
/*
* Copy the unicast source address into the mac_info_t, but only if
* the MAC-Type defines a non-zero address length. We need to
* handle MAC-Types that have an address length of 0
* (point-to-point protocol MACs for example).
*/
goto fail;
/*
* Copy the fixed 'factory' MAC address from the immutable
* info. This is taken to be the MAC address currently in
* use.
*/
/*
* At this point, we should set up the classification
* rules etc but we delay it till mac_open() so that
* the resource discovery has taken place and we
* know someone wants to use the device. Otherwise
* memory gets allocated for Rx ring structures even
* during probe.
*/
/* Copy the destination address if one is provided. */
}
goto fail;
}
/*
* The format of the m_pdata is specific to the plugin. It is
* passed in as an argument to all of the plugin callbacks. The
* driver can update this information by calling
* mac_pdata_update().
*/
/*
* Verify that the plugin supports MAC plugin data and that
* the supplied data is valid.
*/
goto fail;
mregp->m_pdata_size)) {
goto fail;
}
}
/*
* Register the private properties.
*/
/*
* Stash the driver callbacks into the mac_impl_t, but first sanity
* check to make sure all mandatory callbacks are set.
*/
goto fail;
}
} else {
mip->mi_unsup_note = 0;
}
/*
* Allocate a notification thread. thread_create blocks for memory
* if needed, it never fails.
*/
/*
* Initialize the capabilities
*/
/*
* Enforce the virtrualization level registered.
*/
goto fail;
/*
* The driver needs to register at least rx rings for this
* virtualization level.
*/
goto fail;
}
/*
* The driver must set mc_unicst entry point to NULL when it advertises
* CAP_RINGS for rx groups.
*/
goto fail;
} else {
goto fail;
}
/*
* The driver must set mc_tx entry point to NULL when it advertises
* CAP_RINGS for tx rings.
*/
goto fail;
} else {
goto fail;
}
/*
* Initialize MAC addresses. Must be called after mac_init_rings().
*/
&mip->mi_share_capab);
}
/*
* Initialize the kstats for this device.
*/
/* Zero out any properties. */
/* set the gldv3 flag in dn_flags */
/* Create a style-2 DLPI device */
goto fail;
/* Create a style-1 DLPI device */
goto fail;
}
goto fail;
}
(mac_impl_t *), mip);
/*
* Mark the MAC to be ready for open.
*/
return (0);
fail:
if (style1_created)
if (style2_created)
/* Clean up registered MAC addresses */
/* Clean up registered rings */
/* Clean up notification thread */
}
}
mip->mi_pdata_size = 0;
}
if (minor != 0) {
}
return (err);
}
/*
* Unregister from the GLDv3 framework
*/
int
{
int err;
/* Fail the unregister if there are any open references to this mac. */
return (err);
/*
* Clean up notification thread and wait for it to exit.
*/
}
(void) mod_hash_remove(i_mac_impl_hash,
ASSERT(i_mac_impl_count > 0);
mip->mi_pdata_size = 0;
/*
* Free the list of margin request.
*/
}
/*
* Free the primary MAC address.
*/
/*
* free all rings
*/
/* and the flows */
/*
* Reset the perim related fields to default values before
* kmem_cache_free
*/
mip->mi_state_flags = 0;
return (0);
}
/* DATA RECEPTION */
/*
* This function is invoked for packets received by the MAC driver in
* interrupt context. The ring generation number provided by the driver
* is matched with the ring generation number held in MAC. If they do not
* match, received packets are considered stale packets coming from an older
* assignment of the ring. Drop them.
*/
void
{
return;
}
}
/*
* This function is invoked for each packet received by the underlying
* driver.
*/
void
{
/*
* If there are any promiscuous mode callbacks defined for
* this MAC, pass them a copy if appropriate.
*/
/*
* If the SRS teardown has started, just return. The 'mr'
* continues to be valid until the driver unregisters the mac.
* Hardware classified packets will not make their way up
* beyond this point once the teardown has started. The driver
* is never passed a pointer to a flow entry or SRS or any
* structure that can be freed much before mac_unregister.
*/
return;
}
}
/*
* We check if an SRS is controlling this ring.
* If so, we can directly call the srs_lower_proc
* routine otherwise we need to go through mac_rx_classify
* to reach the right place.
*/
if (hw_classified) {
/*
* This is supposed to be the fast path.
* All packets received though here were steered by
* the hardware classifier, and share the same
* MAC header info.
*/
MR_REFRELE(mr);
return;
}
/* We'll fall through to software classification */
} else {
int err;
if (err == 0) {
return;
}
} else {
}
}
return;
}
}
/* DATA TRANSMISSION */
/*
* A driver's notification to resume transmission, in case of a provider
* without TX rings.
*/
void
{
/*
* Walk the list of MAC clients (mac_client_handle)
* and update
*/
}
/*
* A driver's notification to resume transmission on the specified TX ring.
*/
void
{
}
/* LINK STATE */
/*
* Notify the MAC layer about a link state change
*/
void
{
/*
* Save the link state.
*/
/*
* Send a MAC_NOTE_LINK notification.
*/
}
/* OTHER CONTROL INFORMATION */
/*
* A driver notified us that its primary MAC address has changed.
*/
void
{
return;
/*
* If address doesn't change, do nothing.
*/
return;
}
/*
* Freshen the MAC address value and update all MAC clients that
* share this MAC address.
*/
/*
* Send a MAC_NOTE_UNICST notification.
*/
}
/*
* The provider's hw resources (e.g. rings grouping) has changed.
* Notify the MAC framework to trigger a re-negotiation of the capabilities.
*/
void
{
/*
* Send a MAC_NOTE_RESOURCE notification.
*/
}
/*
* MAC plugin information changed.
*/
int
{
/*
* Verify that the plugin supports MAC plugin data and that the
* supplied data is valid.
*/
return (EINVAL);
return (EINVAL);
/*
* Since the MAC plugin data is used to construct MAC headers that
* were cached in fast-path headers, we need to flush fast-path
* information for links associated with this mac.
*/
return (0);
}
/*
* Invoked by driver as well as the framework to notify its capability change.
*/
void
{
/* Send MAC_NOTE_CAPAB_CHG notification */
}
int
{
return (EINVAL);
/* Send a MAC_NOTE_SDU_SIZE notification. */
return (0);
}
/* PRIVATE FUNCTIONS, FOR INTERNAL USE ONLY */
/*
* Updates the mac_impl structure with the current state of the link
*/
static void
{
/*
* If no change, then it is not interesting.
*/
return;
switch (mip->mi_linkstate) {
case LINK_STATE_UP:
char det[200];
} else {
}
break;
case LINK_STATE_DOWN:
/*
* Only transitions from UP to DOWN are interesting
*/
break;
case LINK_STATE_UNKNOWN:
/*
* This case is normally not interesting.
*/
break;
}
}
/*
* Main routine for the callbacks notifications thread
*/
static void
i_mac_notify_thread(void *arg)
{
"i_mac_notify_thread");
for (;;) {
if (bits == 0) {
continue;
}
mip->mi_notify_bits = 0;
/* request to quit */
break;
}
/*
* Log link changes.
*/
/*
* Do notification callbacks for each notification type.
*/
continue;
}
/*
* Walk the list of notifications.
*/
}
&mip->mi_notify_cb_list);
}
}
/* CALLB_CPR_EXIT drops the lock */
thread_exit();
}
/*
* Signal the i_mac_notify_thread asking it to quit.
* Then wait till it is done.
*/
void
{
}
/* Necessary clean up before doing kmem_cache_free */
mip->mi_notify_bits = 0;
}
/*
* Entry point invoked by drivers to dynamically add a ring to an
* existing group.
*/
int
{
int ret;
/*
* Only RX rings can be added or removed by drivers currently.
*/
return (ret);
}
/*
* Entry point invoked by drivers to dynamically remove a ring
* from an existing group. The specified ring handle must no longer
* be used by the driver after a call to this function.
*/
void
{
/*
* Only RX rings can be added or removed by drivers currently.
*/
}