/*
* 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 2010 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* The softmac driver is used to "unify" non-GLDv3 drivers to the GLDv3
* framework. It also creates the kernel datalink structure for each
* physical network device.
*
* Specifically, a softmac will be created for each physical network device
* (dip) during the device's post-attach process. When this softmac is
* created, the following will also be done:
* - create the device's mapping;
* - register the mac if this is a non-GLDv3 device and the media type is
* supported by the GLDv3 framework;
* - create the kernel data-link structure for this physical device;
*
* This softmac will be destroyed during the device's pre-detach process,
* and all the above will be undone.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* Used as a parameter to the mod hash walk of softmac structures */
typedef struct {
softmac_t *smw_softmac;
boolean_t smw_retry;
} softmac_walk_t;
/*
* Softmac hash table including softmacs for both style-2 and style-1 devices.
*/
static krwlock_t softmac_hash_lock;
static mod_hash_t *softmac_hash;
static kmutex_t smac_global_lock;
static kcondvar_t smac_global_cv;
static kmem_cache_t *softmac_cachep;
#define SOFTMAC_HASHSZ 64
static void softmac_create_task(void *);
static void softmac_mac_register(softmac_t *);
static int softmac_create_datalink(softmac_t *);
static int softmac_m_start(void *);
static void softmac_m_stop(void *);
static int softmac_m_open(void *);
static void softmac_m_close(void *);
static boolean_t softmac_m_getcapab(void *, mac_capab_t, void *);
static int softmac_m_setprop(void *, const char *, mac_prop_id_t,
uint_t, const void *);
static int softmac_m_getprop(void *, const char *, mac_prop_id_t,
uint_t, void *);
static void softmac_m_propinfo(void *, const char *, mac_prop_id_t,
mac_prop_info_handle_t);
#define SOFTMAC_M_CALLBACK_FLAGS \
(MC_IOCTL | MC_GETCAPAB | MC_OPEN | MC_CLOSE | MC_SETPROP | \
MC_GETPROP | MC_PROPINFO)
static mac_callbacks_t softmac_m_callbacks = {
SOFTMAC_M_CALLBACK_FLAGS,
softmac_m_stat,
softmac_m_start,
softmac_m_stop,
softmac_m_promisc,
softmac_m_multicst,
softmac_m_unicst,
softmac_m_tx,
NULL,
softmac_m_ioctl,
softmac_m_getcapab,
softmac_m_open,
softmac_m_close,
softmac_m_setprop,
softmac_m_getprop,
softmac_m_propinfo
};
/*ARGSUSED*/
static int
softmac_constructor(void *buf, void *arg, int kmflag)
{
softmac_t *softmac = buf;
bzero(buf, sizeof (softmac_t));
mutex_init(&softmac->smac_mutex, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&softmac->smac_active_mutex, NULL, MUTEX_DEFAULT, NULL);
mutex_init(&softmac->smac_fp_mutex, NULL, MUTEX_DEFAULT, NULL);
cv_init(&softmac->smac_cv, NULL, CV_DEFAULT, NULL);
cv_init(&softmac->smac_fp_cv, NULL, CV_DEFAULT, NULL);
list_create(&softmac->smac_sup_list, sizeof (softmac_upper_t),
offsetof(softmac_upper_t, su_list_node));
return (0);
}
/*ARGSUSED*/
static void
softmac_destructor(void *buf, void *arg)
{
softmac_t *softmac = buf;
ASSERT(softmac->smac_fp_disable_clients == 0);
ASSERT(!softmac->smac_fastpath_admin_disabled);
ASSERT(!(softmac->smac_flags & SOFTMAC_ATTACH_DONE));
ASSERT(softmac->smac_hold_cnt == 0);
ASSERT(softmac->smac_attachok_cnt == 0);
ASSERT(softmac->smac_mh == NULL);
ASSERT(softmac->smac_softmac[0] == NULL &&
softmac->smac_softmac[1] == NULL);
ASSERT(softmac->smac_lower == NULL);
ASSERT(softmac->smac_active == B_FALSE);
ASSERT(softmac->smac_nactive == 0);
ASSERT(list_is_empty(&softmac->smac_sup_list));
list_destroy(&softmac->smac_sup_list);
mutex_destroy(&softmac->smac_mutex);
mutex_destroy(&softmac->smac_active_mutex);
mutex_destroy(&softmac->smac_fp_mutex);
cv_destroy(&softmac->smac_cv);
cv_destroy(&softmac->smac_fp_cv);
}
void
softmac_init()
{
softmac_hash = mod_hash_create_extended("softmac_hash",
SOFTMAC_HASHSZ, mod_hash_null_keydtor, mod_hash_null_valdtor,
mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP);
rw_init(&softmac_hash_lock, NULL, RW_DEFAULT, NULL);
mutex_init(&smac_global_lock, NULL, MUTEX_DRIVER, NULL);
cv_init(&smac_global_cv, NULL, CV_DRIVER, NULL);
softmac_cachep = kmem_cache_create("softmac_cache",
sizeof (softmac_t), 0, softmac_constructor,
softmac_destructor, NULL, NULL, NULL, 0);
ASSERT(softmac_cachep != NULL);
softmac_fp_init();
}
void
softmac_fini()
{
softmac_fp_fini();
kmem_cache_destroy(softmac_cachep);
rw_destroy(&softmac_hash_lock);
mod_hash_destroy_hash(softmac_hash);
mutex_destroy(&smac_global_lock);
cv_destroy(&smac_global_cv);
}
/* ARGSUSED */
static uint_t
softmac_exist(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
{
boolean_t *pexist = arg;
*pexist = B_TRUE;
return (MH_WALK_TERMINATE);
}
boolean_t
softmac_busy()
{
boolean_t exist = B_FALSE;
rw_enter(&softmac_hash_lock, RW_READER);
mod_hash_walk(softmac_hash, softmac_exist, &exist);
rw_exit(&softmac_hash_lock);
return (exist);
}
/*
*
* softmac_create() is called for each minor node during the post-attach of
* each DDI_NT_NET device instance. Note that it is possible that a device
* instance has two minor nodes (DLPI style-1 and style-2), so that for that
* specific device, softmac_create() could be called twice.
*
* A softmac_t is used to track each DDI_NT_NET device, and a softmac_dev_t
* is created to track each minor node.
*
* For each minor node of a legacy device, a taskq is started to finish
* softmac_mac_register(), which will finish the rest of work (see comments
* above softmac_mac_register()).
*
* softmac state machine
* --------------------------------------------------------------------------
* OLD STATE EVENT NEW STATE
* --------------------------------------------------------------------------
* UNINIT attach of 1st minor node ATTACH_INPROG
* okcnt = 0 net_postattach -> softmac_create okcnt = 1
*
* ATTACH_INPROG attach of 2nd minor node (GLDv3) ATTACH_DONE
* okcnt = 1 net_postattach -> softmac_create okcnt = 2
*
* ATTACH_INPROG attach of 2nd minor node (legacy) ATTACH_INPROG
* okcnt = 1 net_postattach -> softmac_create okcnt = 2
* schedule softmac_mac_register
*
* ATTACH_INPROG legacy device node ATTACH_DONE
* okcnt = 2 softmac_mac_register okcnt = 2
*
* ATTACH_DONE detach of 1st minor node DETACH_INPROG
* okcnt = 2 (success) okcnt = 1
*
* DETACH_INPROG detach of 2nd minor node UNINIT (or free)
* okcnt = 1 (success) okcnt = 0
*
* ATTACH_DONE detach failure state unchanged
* DETACH_INPROG left = okcnt
*
* DETACH_INPROG reattach ATTACH_INPROG
* okcnt = 0,1 net_postattach -> softmac_create
*
* ATTACH_DONE reattach ATTACH_DONE
* left != 0 net_postattach -> softmac_create left = 0
*
* Abbreviation notes:
* states have SOFTMAC_ prefix,
* okcnt - softmac_attach_okcnt,
* left - softmac_attached_left
*/
#ifdef DEBUG
void
softmac_state_verify(softmac_t *softmac)
{
ASSERT(MUTEX_HELD(&softmac->smac_mutex));
/*
* There are at most 2 minor nodes, one per DLPI style
*/
ASSERT(softmac->smac_cnt <= 2 && softmac->smac_attachok_cnt <= 2);
/*
* The smac_attachok_cnt represents the number of attaches i.e. the
* number of times net_postattach -> softmac_create() has been called
* for a device instance.
*/
ASSERT(softmac->smac_attachok_cnt == SMAC_NONZERO_NODECNT(softmac));
/*
* softmac_create (or softmac_mac_register) -> softmac_create_datalink
* happens only after all minor nodes have been attached
*/
ASSERT(softmac->smac_state != SOFTMAC_ATTACH_DONE ||
softmac->smac_attachok_cnt == softmac->smac_cnt);
if (softmac->smac_attachok_cnt == 0) {
ASSERT(softmac->smac_state == SOFTMAC_UNINIT);
ASSERT(softmac->smac_mh == NULL);
} else if (softmac->smac_attachok_cnt < softmac->smac_cnt) {
ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG ||
softmac->smac_state == SOFTMAC_DETACH_INPROG);
ASSERT(softmac->smac_mh == NULL);
} else {
/*
* In the stable condition the state whould be
* SOFTMAC_ATTACH_DONE. But there is a small transient window
* in softmac_destroy where we change the state to
* SOFTMAC_DETACH_INPROG and drop the lock before doing
* the link destroy
*/
ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
ASSERT(softmac->smac_state != SOFTMAC_UNINIT);
}
if (softmac->smac_mh != NULL)
ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
}
#endif
#ifdef DEBUG
#define SOFTMAC_STATE_VERIFY(softmac) softmac_state_verify(softmac)
#else
#define SOFTMAC_STATE_VERIFY(softmac)
#endif
int
softmac_create(dev_info_t *dip, dev_t dev)
{
char devname[MAXNAMELEN];
softmac_t *softmac;
softmac_dev_t *softmac_dev = NULL;
int index;
int ppa, err = 0;
/*
* Force the softmac driver to be attached.
*/
if (i_ddi_attach_pseudo_node(SOFTMAC_DEV_NAME) == NULL) {
cmn_err(CE_WARN, "softmac_create:softmac attach fails");
return (ENXIO);
}
if (GLDV3_DRV(ddi_driver_major(dip))) {
minor_t minor = getminor(dev);
/*
* For GLDv3, we don't care about the DLPI style 2
* compatibility node. (We know that all such devices
* have style 1 nodes.)
*/
if ((strcmp(ddi_driver_name(dip), "clone") == 0) ||
(getmajor(dev) == ddi_name_to_major("clone")) ||
(minor == 0)) {
return (0);
}
/*
* Likewise, we know that the minor number for DLPI style 1
* nodes is constrained to a maximum value.
*/
if (minor >= DLS_MAX_MINOR) {
return (ENOTSUP);
}
/*
* Otherwise we can decode the instance from the minor number,
* which allows for situations with multiple mac instances
* for a single dev_info_t.
*/
ppa = DLS_MINOR2INST(minor);
} else {
/*
* For legacy drivers, we just have to limit them to
* two minor nodes, one style 1 and one style 2, and
* we assume the ddi_get_instance() is the PPA.
* Drivers that need more flexibility should be ported
* to GLDv3.
*/
ppa = ddi_get_instance(dip);
if (i_ddi_minor_node_count(dip, DDI_NT_NET) > 2) {
cmn_err(CE_WARN, "%s has more than 2 minor nodes; "
"unsupported", devname);
return (ENOTSUP);
}
}
(void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_driver_name(dip), ppa);
/*
* Check whether the softmac for the specified device already exists
*/
rw_enter(&softmac_hash_lock, RW_WRITER);
if ((mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
(mod_hash_val_t *)&softmac)) != 0) {
softmac = kmem_cache_alloc(softmac_cachep, KM_SLEEP);
(void) strlcpy(softmac->smac_devname, devname, MAXNAMELEN);
err = mod_hash_insert(softmac_hash,
(mod_hash_key_t)softmac->smac_devname,
(mod_hash_val_t)softmac);
ASSERT(err == 0);
mutex_enter(&smac_global_lock);
cv_broadcast(&smac_global_cv);
mutex_exit(&smac_global_lock);
}
mutex_enter(&softmac->smac_mutex);
SOFTMAC_STATE_VERIFY(softmac);
if (softmac->smac_state != SOFTMAC_ATTACH_DONE)
softmac->smac_state = SOFTMAC_ATTACH_INPROG;
if (softmac->smac_attachok_cnt == 0) {
/*
* Initialize the softmac if this is the post-attach of the
* first minor node.
*/
softmac->smac_flags = 0;
softmac->smac_umajor = ddi_driver_major(dip);
softmac->smac_uppa = ppa;
/*
* For GLDv3, we ignore the style 2 node (see the logic
* above on that), and we should have exactly one attach
* per MAC instance (possibly more than one per dev_info_t).
*/
if (GLDV3_DRV(ddi_driver_major(dip))) {
softmac->smac_flags |= SOFTMAC_GLDV3;
softmac->smac_cnt = 1;
} else {
softmac->smac_cnt =
i_ddi_minor_node_count(dip, DDI_NT_NET);
}
}
index = (getmajor(dev) == ddi_name_to_major("clone"));
if (softmac->smac_softmac[index] != NULL) {
/*
* This is possible if the post_attach() is called after
* pre_detach() fails. This seems to be a defect of the DACF
* framework. We work around it by using a smac_attached_left
* field that tracks this
*/
ASSERT(softmac->smac_attached_left != 0);
softmac->smac_attached_left--;
mutex_exit(&softmac->smac_mutex);
rw_exit(&softmac_hash_lock);
return (0);
}
mutex_exit(&softmac->smac_mutex);
rw_exit(&softmac_hash_lock);
softmac_dev = kmem_zalloc(sizeof (softmac_dev_t), KM_SLEEP);
softmac_dev->sd_dev = dev;
mutex_enter(&softmac->smac_mutex);
softmac->smac_softmac[index] = softmac_dev;
/*
* Continue to register the mac and create the datalink only when all
* the minor nodes are attached.
*/
if (++softmac->smac_attachok_cnt != softmac->smac_cnt) {
mutex_exit(&softmac->smac_mutex);
return (0);
}
/*
* All of the minor nodes have been attached; start a taskq
* to do the rest of the work. We use a taskq instead of
* doing the work here because:
*
* We could be called as a result of a open() system call
* where spec_open() already SLOCKED the snode. Using a taskq
* sidesteps the risk that our ldi_open_by_dev() call would
* deadlock trying to set SLOCKED on the snode again.
*
* The devfs design requires that the downcalls don't use any
* interruptible cv_wait which happens when we do door upcalls.
* Otherwise the downcalls which may be holding devfs resources
* may cause a deadlock if the thread is stopped. Also we need to make
* sure these downcalls into softmac_create or softmac_destroy
* don't cv_wait on any devfs related condition. Thus softmac_destroy
* returns EBUSY if the asynchronous threads started in softmac_create
* haven't finished.
*/
(void) taskq_dispatch(system_taskq, softmac_create_task,
softmac, TQ_SLEEP);
mutex_exit(&softmac->smac_mutex);
return (0);
}
static boolean_t
softmac_m_getcapab(void *arg, mac_capab_t cap, void *cap_data)
{
softmac_t *softmac = arg;
if (!(softmac->smac_capab_flags & cap))
return (B_FALSE);
switch (cap) {
case MAC_CAPAB_HCKSUM: {
uint32_t *txflags = cap_data;
*txflags = softmac->smac_hcksum_txflags;
break;
}
case MAC_CAPAB_LEGACY: {
mac_capab_legacy_t *legacy = cap_data;
/*
* The caller is not interested in the details.
*/
if (legacy == NULL)
break;
legacy->ml_unsup_note = ~softmac->smac_notifications &
(DL_NOTE_LINK_UP | DL_NOTE_LINK_DOWN | DL_NOTE_SPEED);
legacy->ml_active_set = softmac_active_set;
legacy->ml_active_clear = softmac_active_clear;
legacy->ml_fastpath_disable = softmac_fastpath_disable;
legacy->ml_fastpath_enable = softmac_fastpath_enable;
legacy->ml_dev = makedevice(softmac->smac_umajor,
softmac->smac_uppa + 1);
break;
}
/*
* For the capabilities below, there's nothing for us to fill in;
* simply return B_TRUE if we support it.
*/
case MAC_CAPAB_NO_ZCOPY:
case MAC_CAPAB_NO_NATIVEVLAN:
default:
break;
}
return (B_TRUE);
}
static int
softmac_update_info(softmac_t *softmac, datalink_id_t *linkidp)
{
datalink_id_t linkid = DATALINK_INVALID_LINKID;
uint32_t media;
int err;
if ((err = dls_mgmt_update(softmac->smac_devname, softmac->smac_media,
softmac->smac_flags & SOFTMAC_NOSUPP, &media, &linkid)) == 0) {
*linkidp = linkid;
}
if (err == EEXIST) {
/*
* There is a link name conflict. Either:
*
* - An existing link with the same device name with a
* different media type from of the given type.
* Mark this link back to persistent only; or
*
* - We cannot assign the "suggested" name because
* GLDv3 and therefore vanity naming is not supported
* for this link type. Delete this link's mapping.
*/
if (media != softmac->smac_media) {
cmn_err(CE_WARN, "%s device %s conflicts with "
"existing %s device %s.",
dl_mactypestr(softmac->smac_media),
softmac->smac_devname, dl_mactypestr(media),
softmac->smac_devname);
(void) dls_mgmt_destroy(linkid, B_FALSE);
} else {
cmn_err(CE_WARN, "link name %s is already in-use.",
softmac->smac_devname);
(void) dls_mgmt_destroy(linkid, B_TRUE);
}
cmn_err(CE_WARN, "%s device might not be available "
"for use.", softmac->smac_devname);
cmn_err(CE_WARN, "See dladm(1M) for more information.");
}
return (err);
}
/*
* This function:
* 1. provides the link's media type to dlmgmtd.
* 2. creates the GLDv3 datalink if the media type is supported by GLDv3.
*/
static int
softmac_create_datalink(softmac_t *softmac)
{
datalink_id_t linkid = DATALINK_INVALID_LINKID;
int err;
/*
* Inform dlmgmtd of this link so that softmac_hold_device() is able
* to know the existence of this link. If this failed with EBADF,
* it might be because dlmgmtd was not started in time (e.g.,
* diskless boot); ignore the failure and continue to create
* the GLDv3 datalink if needed.
*/
err = dls_mgmt_create(softmac->smac_devname,
makedevice(softmac->smac_umajor, softmac->smac_uppa + 1),
DATALINK_CLASS_PHYS, DL_OTHER, B_TRUE, &linkid);
if (err != 0 && err != EBADF)
return (err);
/*
* Provide the media type of the physical link to dlmgmtd.
*/
if ((err != EBADF) &&
((err = softmac_update_info(softmac, &linkid)) != 0)) {
return (err);
}
/*
* Create the GLDv3 datalink.
*/
if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
err = dls_devnet_create(softmac->smac_mh, linkid,
crgetzoneid(CRED()));
if (err != 0) {
cmn_err(CE_WARN, "dls_devnet_create failed for %s",
softmac->smac_devname);
return (err);
}
}
if (linkid == DATALINK_INVALID_LINKID) {
mutex_enter(&softmac->smac_mutex);
softmac->smac_flags |= SOFTMAC_NEED_RECREATE;
mutex_exit(&softmac->smac_mutex);
}
return (0);
}
static void
softmac_create_task(void *arg)
{
softmac_t *softmac = arg;
mac_handle_t mh;
int err;
if (!GLDV3_DRV(softmac->smac_umajor)) {
softmac_mac_register(softmac);
return;
}
if ((err = mac_open(softmac->smac_devname, &mh)) != 0)
goto done;
mutex_enter(&softmac->smac_mutex);
softmac->smac_media = (mac_info(mh))->mi_nativemedia;
softmac->smac_mh = mh;
mutex_exit(&softmac->smac_mutex);
/*
* We can safely release the reference on the mac because
* this mac will only be unregistered and destroyed when
* the device detaches, and the softmac will be destroyed
* before then (in the pre-detach routine of the device).
*/
mac_close(mh);
/*
* Create the GLDv3 datalink for this mac.
*/
err = softmac_create_datalink(softmac);
done:
mutex_enter(&softmac->smac_mutex);
if (err != 0)
softmac->smac_mh = NULL;
softmac->smac_attacherr = err;
softmac->smac_state = SOFTMAC_ATTACH_DONE;
cv_broadcast(&softmac->smac_cv);
mutex_exit(&softmac->smac_mutex);
}
/*
* This function is only called for legacy devices. It:
* 1. registers the MAC for the legacy devices whose media type is supported
* by the GLDv3 framework.
* 2. creates the GLDv3 datalink if the media type is supported by GLDv3.
*/
static void
softmac_mac_register(softmac_t *softmac)
{
softmac_dev_t *softmac_dev;
dev_t dev;
ldi_handle_t lh = NULL;
ldi_ident_t li = NULL;
int index;
boolean_t native_vlan = B_FALSE;
int err;
/*
* Note that we do not need any locks to access this softmac pointer,
* as softmac_destroy() will wait until this function is called.
*/
ASSERT(softmac != NULL);
ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG &&
softmac->smac_attachok_cnt == softmac->smac_cnt);
if ((err = ldi_ident_from_dip(softmac_dip, &li)) != 0) {
mutex_enter(&softmac->smac_mutex);
goto done;
}
/*
* Determine whether this legacy device support VLANs by opening
* the style-2 device node (if it exists) and attaching to a VLAN
* PPA (1000 + ppa).
*/
dev = makedevice(ddi_name_to_major("clone"), softmac->smac_umajor);
err = ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh, li);
if (err == 0) {
if (dl_attach(lh, softmac->smac_uppa + 1 * 1000, NULL) == 0)
native_vlan = B_TRUE;
(void) ldi_close(lh, FREAD|FWRITE, kcred);
}
err = EINVAL;
for (index = 0; index < 2; index++) {
dl_info_ack_t dlia;
dl_error_ack_t dlea;
uint32_t notes;
struct strioctl iocb;
uint32_t margin;
int rval;
if ((softmac_dev = softmac->smac_softmac[index]) == NULL)
continue;
softmac->smac_dev = dev = softmac_dev->sd_dev;
if (ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh,
li) != 0) {
continue;
}
/*
* Pop all the intermediate modules in order to negotiate
* capabilities correctly.
*/
while (ldi_ioctl(lh, I_POP, 0, FKIOCTL, kcred, &rval) == 0)
;
/* DLPI style-1 or DLPI style-2? */
if ((rval = dl_info(lh, &dlia, NULL, NULL, &dlea)) != 0) {
if (rval == ENOTSUP) {
cmn_err(CE_NOTE, "softmac: received "
"DL_ERROR_ACK to DL_INFO_ACK; "
"DLPI errno 0x%x, UNIX errno %d",
dlea.dl_errno, dlea.dl_unix_errno);
}
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
/*
* Currently only DL_ETHER has GLDv3 mac plugin support.
* For media types that GLDv3 does not support, create a
* link id for it.
*/
if ((softmac->smac_media = dlia.dl_mac_type) != DL_ETHER) {
(void) ldi_close(lh, FREAD|FWRITE, kcred);
err = 0;
break;
}
if ((dlia.dl_provider_style == DL_STYLE2) &&
(dl_attach(lh, softmac->smac_uppa, NULL) != 0)) {
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
if ((rval = dl_bind(lh, 0, NULL)) != 0) {
if (rval == ENOTSUP) {
cmn_err(CE_NOTE, "softmac: received "
"DL_ERROR_ACK to DL_BIND_ACK; "
"DLPI errno 0x%x, UNIX errno %d",
dlea.dl_errno, dlea.dl_unix_errno);
}
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
/*
* Call dl_info() after dl_bind() because some drivers only
* provide correct information (e.g. MAC address) once bound.
*/
softmac->smac_addrlen = sizeof (softmac->smac_unicst_addr);
if ((rval = dl_info(lh, &dlia, softmac->smac_unicst_addr,
&softmac->smac_addrlen, &dlea)) != 0) {
if (rval == ENOTSUP) {
cmn_err(CE_NOTE, "softmac: received "
"DL_ERROR_ACK to DL_INFO_ACK; "
"DLPI errno 0x%x, UNIX errno %d",
dlea.dl_errno, dlea.dl_unix_errno);
}
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
softmac->smac_style = dlia.dl_provider_style;
softmac->smac_saplen = ABS(dlia.dl_sap_length);
softmac->smac_min_sdu = dlia.dl_min_sdu;
softmac->smac_max_sdu = dlia.dl_max_sdu;
if ((softmac->smac_saplen != sizeof (uint16_t)) ||
(softmac->smac_addrlen != ETHERADDRL) ||
(dlia.dl_brdcst_addr_length != ETHERADDRL) ||
(dlia.dl_brdcst_addr_offset == 0)) {
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
/*
* Check other DLPI capabilities. Note that this must be after
* dl_bind() because some drivers return DL_ERROR_ACK if the
* stream is not bound. It is also before mac_register(), so
* we don't need any lock protection here.
*/
softmac->smac_capab_flags =
(MAC_CAPAB_NO_ZCOPY | MAC_CAPAB_LEGACY);
softmac->smac_no_capability_req = B_FALSE;
if (softmac_fill_capab(lh, softmac) != 0)
softmac->smac_no_capability_req = B_TRUE;
/*
* Check the margin of the underlying driver.
*/
margin = 0;
iocb.ic_cmd = DLIOCMARGININFO;
iocb.ic_timout = INFTIM;
iocb.ic_len = sizeof (margin);
iocb.ic_dp = (char *)&margin;
softmac->smac_margin = 0;
if (ldi_ioctl(lh, I_STR, (intptr_t)&iocb, FKIOCTL, kcred,
&rval) == 0) {
softmac->smac_margin = margin;
}
/*
* If the legacy driver doesn't support DLIOCMARGININFO, but
* it can support native VLAN, correct its margin value to 4.
*/
if (native_vlan) {
if (softmac->smac_margin == 0)
softmac->smac_margin = VLAN_TAGSZ;
} else {
softmac->smac_capab_flags |= MAC_CAPAB_NO_NATIVEVLAN;
}
/*
* Not all drivers support DL_NOTIFY_REQ, so ignore ENOTSUP.
*/
softmac->smac_notifications = 0;
notes = DL_NOTE_PHYS_ADDR | DL_NOTE_LINK_UP | DL_NOTE_LINK_DOWN;
switch (dl_notify(lh, ¬es, NULL)) {
case 0:
softmac->smac_notifications = notes;
break;
case ENOTSUP:
break;
default:
(void) ldi_close(lh, FREAD|FWRITE, kcred);
continue;
}
(void) ldi_close(lh, FREAD|FWRITE, kcred);
err = 0;
break;
}
ldi_ident_release(li);
mutex_enter(&softmac->smac_mutex);
if (err != 0)
goto done;
if (softmac->smac_media != DL_ETHER)
softmac->smac_flags |= SOFTMAC_NOSUPP;
/*
* Finally, we're ready to register ourselves with the MAC layer
* interface; if this succeeds, we're all ready to start()
*/
if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
mac_register_t *macp;
if ((macp = mac_alloc(MAC_VERSION)) == NULL) {
err = ENOMEM;
goto done;
}
macp->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
macp->m_driver = softmac;
macp->m_dip = softmac_dip;
macp->m_margin = softmac->smac_margin;
macp->m_src_addr = softmac->smac_unicst_addr;
macp->m_min_sdu = softmac->smac_min_sdu;
macp->m_max_sdu = softmac->smac_max_sdu;
macp->m_callbacks = &softmac_m_callbacks;
macp->m_instance = (uint_t)-1;
err = mac_register(macp, &softmac->smac_mh);
mac_free(macp);
if (err != 0) {
cmn_err(CE_WARN, "mac_register failed for %s",
softmac->smac_devname);
goto done;
}
}
mutex_exit(&softmac->smac_mutex);
/*
* Try to create the datalink for this softmac.
*/
if ((err = softmac_create_datalink(softmac)) != 0) {
if (!(softmac->smac_flags & SOFTMAC_NOSUPP))
(void) mac_unregister(softmac->smac_mh);
mutex_enter(&softmac->smac_mutex);
softmac->smac_mh = NULL;
goto done;
}
/*
* If succeed, create the thread which handles the DL_NOTIFY_IND from
* the lower stream.
*/
mutex_enter(&softmac->smac_mutex);
if (softmac->smac_mh != NULL) {
softmac->smac_notify_thread = thread_create(NULL, 0,
softmac_notify_thread, softmac, 0, &p0,
TS_RUN, minclsyspri);
}
done:
ASSERT(softmac->smac_state == SOFTMAC_ATTACH_INPROG &&
softmac->smac_attachok_cnt == softmac->smac_cnt);
softmac->smac_state = SOFTMAC_ATTACH_DONE;
softmac->smac_attacherr = err;
cv_broadcast(&softmac->smac_cv);
mutex_exit(&softmac->smac_mutex);
}
int
softmac_destroy(dev_info_t *dip, dev_t dev)
{
char devname[MAXNAMELEN];
softmac_t *softmac;
softmac_dev_t *softmac_dev;
int index;
int ppa, err;
datalink_id_t linkid;
mac_handle_t smac_mh;
uint32_t smac_flags;
if (GLDV3_DRV(ddi_driver_major(dip))) {
minor_t minor = getminor(dev);
/*
* For an explanation of this logic, see the
* equivalent code in softmac_create.
*/
if ((strcmp(ddi_driver_name(dip), "clone") == 0) ||
(getmajor(dev) == ddi_name_to_major("clone")) ||
(minor == 0)) {
return (0);
}
if (minor >= DLS_MAX_MINOR) {
return (ENOTSUP);
}
ppa = DLS_MINOR2INST(minor);
} else {
ppa = ddi_get_instance(dip);
}
(void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_driver_name(dip), ppa);
/*
* We are called only from the predetach entry point. The DACF
* framework ensures there can't be a concurrent postattach call
* for the same softmac. The softmac found out from the modhash
* below can't vanish beneath us since this is the only place where
* it is deleted.
*/
err = mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
(mod_hash_val_t *)&softmac);
ASSERT(err == 0);
mutex_enter(&softmac->smac_mutex);
SOFTMAC_STATE_VERIFY(softmac);
/*
* Fail the predetach routine if this softmac is in-use.
* Make sure these downcalls into softmac_create or softmac_destroy
* don't cv_wait on any devfs related condition. Thus softmac_destroy
* returns EBUSY if the asynchronous thread started in softmac_create
* hasn't finished
*/
if ((softmac->smac_hold_cnt != 0) ||
(softmac->smac_state == SOFTMAC_ATTACH_INPROG)) {
softmac->smac_attached_left = softmac->smac_attachok_cnt;
mutex_exit(&softmac->smac_mutex);
return (EBUSY);
}
/*
* Even if the predetach of one minor node has already failed
* (smac_attached_left is not 0), the DACF framework will continue
* to call the predetach routines of the other minor nodes,
* so we fail these calls here.
*/
if (softmac->smac_attached_left != 0) {
mutex_exit(&softmac->smac_mutex);
return (EBUSY);
}
smac_mh = softmac->smac_mh;
smac_flags = softmac->smac_flags;
softmac->smac_state = SOFTMAC_DETACH_INPROG;
mutex_exit(&softmac->smac_mutex);
if (smac_mh != NULL) {
/*
* This is the first minor node that is being detached for this
* softmac.
*/
ASSERT(softmac->smac_attachok_cnt == softmac->smac_cnt);
if (!(smac_flags & SOFTMAC_NOSUPP)) {
if ((err = dls_devnet_destroy(smac_mh, &linkid,
B_FALSE)) != 0) {
goto error;
}
}
/*
* If softmac_mac_register() succeeds in registering the mac
* of the legacy device, unregister it.
*/
if (!(smac_flags & (SOFTMAC_GLDV3 | SOFTMAC_NOSUPP))) {
if ((err = mac_disable_nowait(smac_mh)) != 0) {
(void) dls_devnet_create(smac_mh, linkid,
crgetzoneid(CRED()));
goto error;
}
/*
* Ask softmac_notify_thread to quit, and wait for
* that to be done.
*/
mutex_enter(&softmac->smac_mutex);
softmac->smac_flags |= SOFTMAC_NOTIFY_QUIT;
cv_broadcast(&softmac->smac_cv);
while (softmac->smac_notify_thread != NULL) {
cv_wait(&softmac->smac_cv,
&softmac->smac_mutex);
}
mutex_exit(&softmac->smac_mutex);
VERIFY(mac_unregister(smac_mh) == 0);
}
softmac->smac_mh = NULL;
}
/*
* Free softmac_dev
*/
rw_enter(&softmac_hash_lock, RW_WRITER);
mutex_enter(&softmac->smac_mutex);
ASSERT(softmac->smac_state == SOFTMAC_DETACH_INPROG &&
softmac->smac_attachok_cnt != 0);
softmac->smac_mh = NULL;
index = (getmajor(dev) == ddi_name_to_major("clone"));
softmac_dev = softmac->smac_softmac[index];
ASSERT(softmac_dev != NULL);
softmac->smac_softmac[index] = NULL;
kmem_free(softmac_dev, sizeof (softmac_dev_t));
if (--softmac->smac_attachok_cnt == 0) {
mod_hash_val_t hashval;
softmac->smac_state = SOFTMAC_UNINIT;
if (softmac->smac_hold_cnt != 0) {
/*
* Someone did a softmac_hold_device while we dropped
* the locks. Leave the softmac itself intact which
* will be reused by the reattach
*/
mutex_exit(&softmac->smac_mutex);
rw_exit(&softmac_hash_lock);
return (0);
}
err = mod_hash_remove(softmac_hash,
(mod_hash_key_t)devname,
(mod_hash_val_t *)&hashval);
ASSERT(err == 0);
mutex_exit(&softmac->smac_mutex);
rw_exit(&softmac_hash_lock);
ASSERT(softmac->smac_fp_disable_clients == 0);
softmac->smac_fastpath_admin_disabled = B_FALSE;
kmem_cache_free(softmac_cachep, softmac);
return (0);
}
mutex_exit(&softmac->smac_mutex);
rw_exit(&softmac_hash_lock);
return (0);
error:
mutex_enter(&softmac->smac_mutex);
softmac->smac_attached_left = softmac->smac_attachok_cnt;
softmac->smac_state = SOFTMAC_ATTACH_DONE;
cv_broadcast(&softmac->smac_cv);
mutex_exit(&softmac->smac_mutex);
return (err);
}
/*
* This function is called as the result of a newly started dlmgmtd daemon.
*
* We walk through every softmac that was created but failed to notify
* dlmgmtd about it (whose SOFTMAC_NEED_RECREATE flag is set). This occurs
* when softmacs are created before dlmgmtd is ready. For example, during
* diskless boot, a network device is used (and therefore attached) before
* the datalink-management service starts dlmgmtd.
*/
/* ARGSUSED */
static uint_t
softmac_mac_recreate(mod_hash_key_t key, mod_hash_val_t *val, void *arg)
{
softmac_t *softmac = (softmac_t *)val;
datalink_id_t linkid;
int err;
softmac_walk_t *smwp = arg;
/*
* The framework itself must not hold any locks across calls to the
* mac perimeter. Thus this function does not call any framework
* function that needs to grab the mac perimeter.
*/
ASSERT(RW_READ_HELD(&softmac_hash_lock));
smwp->smw_retry = B_FALSE;
mutex_enter(&softmac->smac_mutex);
SOFTMAC_STATE_VERIFY(softmac);
if (softmac->smac_state == SOFTMAC_ATTACH_INPROG) {
/*
* Wait till softmac_create or softmac_mac_register finishes
* Hold the softmac to ensure it stays around. The wait itself
* is done in the caller, since we need to drop all locks
* including the mod hash's internal lock before calling
* cv_wait.
*/
smwp->smw_retry = B_TRUE;
smwp->smw_softmac = softmac;
softmac->smac_hold_cnt++;
return (MH_WALK_TERMINATE);
}
if ((softmac->smac_state != SOFTMAC_ATTACH_DONE) ||
!(softmac->smac_flags & SOFTMAC_NEED_RECREATE)) {
mutex_exit(&softmac->smac_mutex);
return (MH_WALK_CONTINUE);
}
/*
* Bumping up the smac_hold_cnt allows us to drop the lock. It also
* makes softmac_destroy() return failure on an attempted device detach.
* We don't want to hold the lock across calls to other subsystems
* like kstats, which will happen in the call to dls_devnet_recreate
*/
softmac->smac_hold_cnt++;
mutex_exit(&softmac->smac_mutex);
if (dls_mgmt_create(softmac->smac_devname,
makedevice(softmac->smac_umajor, softmac->smac_uppa + 1),
DATALINK_CLASS_PHYS, softmac->smac_media, B_TRUE, &linkid) != 0) {
softmac_rele_device((dls_dev_handle_t)softmac);
return (MH_WALK_CONTINUE);
}
if ((err = softmac_update_info(softmac, &linkid)) != 0) {
cmn_err(CE_WARN, "softmac: softmac_update_info() for %s "
"failed (%d)", softmac->smac_devname, err);
softmac_rele_device((dls_dev_handle_t)softmac);
return (MH_WALK_CONTINUE);
}
/*
* Create a link for this MAC. The link name will be the same
* as the MAC name.
*/
if (!(softmac->smac_flags & SOFTMAC_NOSUPP)) {
err = dls_devnet_recreate(softmac->smac_mh, linkid);
if (err != 0) {
cmn_err(CE_WARN, "softmac: dls_devnet_recreate() for "
"%s (linkid %d) failed (%d)",
softmac->smac_devname, linkid, err);
}
}
mutex_enter(&softmac->smac_mutex);
softmac->smac_flags &= ~SOFTMAC_NEED_RECREATE;
ASSERT(softmac->smac_hold_cnt != 0);
softmac->smac_hold_cnt--;
mutex_exit(&softmac->smac_mutex);
return (MH_WALK_CONTINUE);
}
/*
* See comments above softmac_mac_recreate().
*/
void
softmac_recreate()
{
softmac_walk_t smw;
softmac_t *softmac;
/*
* Walk through the softmac_hash table. Request to create the
* [link name, linkid] mapping if we failed to do so.
*/
do {
smw.smw_retry = B_FALSE;
rw_enter(&softmac_hash_lock, RW_READER);
mod_hash_walk(softmac_hash, softmac_mac_recreate, &smw);
rw_exit(&softmac_hash_lock);
if (smw.smw_retry) {
/*
* softmac_create or softmac_mac_register hasn't yet
* finished and the softmac is not yet in the
* SOFTMAC_ATTACH_DONE state.
*/
softmac = smw.smw_softmac;
cv_wait(&softmac->smac_cv, &softmac->smac_mutex);
softmac->smac_hold_cnt--;
mutex_exit(&softmac->smac_mutex);
}
} while (smw.smw_retry);
}
static int
softmac_m_start(void *arg)
{
softmac_t *softmac = arg;
softmac_lower_t *slp = softmac->smac_lower;
int err;
ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
/*
* Bind to SAP 2 on token ring, 0 on other interface types.
* (SAP 0 has special significance on token ring).
* Note that the receive-side packets could come anytime after bind.
*/
err = softmac_send_bind_req(slp, softmac->smac_media == DL_TPR ? 2 : 0);
if (err != 0)
return (err);
/*
* Put the lower stream to the DL_PROMISC_SAP mode in order to receive
* all packets of interest.
*
* some driver (e.g. the old legacy eri driver) incorrectly passes up
* packets to DL_PROMISC_SAP stream when the lower stream is not bound,
* so that we send DL_PROMISON_REQ after DL_BIND_REQ.
*/
err = softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_TRUE);
if (err != 0) {
(void) softmac_send_unbind_req(slp);
return (err);
}
/*
* Enable capabilities the underlying driver claims to support.
* Some driver requires this being called after the stream is bound.
*/
if ((err = softmac_capab_enable(slp)) != 0) {
(void) softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_FALSE);
(void) softmac_send_unbind_req(slp);
}
return (err);
}
/* ARGSUSED */
static void
softmac_m_stop(void *arg)
{
softmac_t *softmac = arg;
softmac_lower_t *slp = softmac->smac_lower;
ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
/*
* It is not needed to reset zerocopy, MDT or HCKSUM capabilities.
*/
(void) softmac_send_promisc_req(slp, DL_PROMISC_SAP, B_FALSE);
(void) softmac_send_unbind_req(slp);
}
/*
* Set up the lower stream above the legacy device. There are two different
* type of lower streams:
*
* - Shared lower-stream
*
* Shared by all GLDv3 MAC clients. Put the lower stream to the DLIOCRAW
* mode to send and receive the raw data. Further, put the lower stream into
* DL_PROMISC_SAP mode to receive all packets of interest.
*
* - Dedicated lower-stream
*
* The lower-stream which is dedicated to upper IP/ARP stream. This is used
* as fast-path for IP. In this case, the second argument is the pointer to
* the softmac upper-stream.
*/
int
softmac_lower_setup(softmac_t *softmac, softmac_upper_t *sup,
softmac_lower_t **slpp)
{
ldi_ident_t li;
dev_t dev;
ldi_handle_t lh = NULL;
softmac_lower_t *slp = NULL;
smac_ioc_start_t start_arg;
struct strioctl strioc;
uint32_t notifications;
int err, rval;
if ((err = ldi_ident_from_dip(softmac_dip, &li)) != 0)
return (err);
/*
* The GLDv3 framework makes sure that mac_unregister(), mac_open(),
* and mac_close() cannot be called at the same time. So we don't
* need any protection to access softmac here.
*/
dev = softmac->smac_dev;
err = ldi_open_by_dev(&dev, OTYP_CHR, FREAD|FWRITE, kcred, &lh, li);
ldi_ident_release(li);
if (err != 0)
goto done;
/*
* Pop all the intermediate modules. The autopushed modules will
* be pushed when the softmac node is opened.
*/
while (ldi_ioctl(lh, I_POP, 0, FKIOCTL, kcred, &rval) == 0)
;
if ((softmac->smac_style == DL_STYLE2) &&
((err = dl_attach(lh, softmac->smac_uppa, NULL)) != 0)) {
goto done;
}
/*
* If this is the shared-lower-stream, put the lower stream to
* the DLIOCRAW mode to send/receive raw data.
*/
if ((sup == NULL) && (err = ldi_ioctl(lh, DLIOCRAW, 0, FKIOCTL,
kcred, &rval)) != 0) {
goto done;
}
/*
* Then push the softmac shim layer atop the lower stream.
*/
if ((err = ldi_ioctl(lh, I_PUSH, (intptr_t)SOFTMAC_DEV_NAME, FKIOCTL,
kcred, &rval)) != 0) {
goto done;
}
/*
* Send the ioctl to get the slp pointer.
*/
strioc.ic_cmd = SMAC_IOC_START;
strioc.ic_timout = INFTIM;
strioc.ic_len = sizeof (start_arg);
strioc.ic_dp = (char *)&start_arg;
if ((err = ldi_ioctl(lh, I_STR, (intptr_t)&strioc, FKIOCTL,
kcred, &rval)) != 0) {
goto done;
}
slp = start_arg.si_slp;
slp->sl_sup = sup;
slp->sl_lh = lh;
slp->sl_softmac = softmac;
*slpp = slp;
if (sup != NULL) {
slp->sl_rxinfo = &sup->su_rxinfo;
} else {
/*
* Send DL_NOTIFY_REQ to enable certain DL_NOTIFY_IND.
* We don't have to wait for the ack.
*/
notifications = DL_NOTE_PHYS_ADDR | DL_NOTE_LINK_UP |
DL_NOTE_LINK_DOWN | DL_NOTE_PROMISC_ON_PHYS |
DL_NOTE_PROMISC_OFF_PHYS;
(void) softmac_send_notify_req(slp,
(notifications & softmac->smac_notifications));
}
done:
if (err != 0)
(void) ldi_close(lh, FREAD|FWRITE, kcred);
return (err);
}
static int
softmac_m_open(void *arg)
{
softmac_t *softmac = arg;
softmac_lower_t *slp;
int err;
ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
if ((err = softmac_lower_setup(softmac, NULL, &slp)) != 0)
return (err);
softmac->smac_lower = slp;
return (0);
}
static void
softmac_m_close(void *arg)
{
softmac_t *softmac = arg;
softmac_lower_t *slp;
ASSERT(MAC_PERIM_HELD(softmac->smac_mh));
slp = softmac->smac_lower;
ASSERT(slp != NULL);
/*
* Note that slp is destroyed when lh is closed.
*/
(void) ldi_close(slp->sl_lh, FREAD|FWRITE, kcred);
softmac->smac_lower = NULL;
}
/*
* Softmac supports two priviate link properteis:
*
* - "_fastpath"
*
* This is a read-only link property which points out the current data-path
* model of the given legacy link. The possible values are "disabled" and
* "enabled".
*
* - "_disable_fastpath"
*
* This is a read-write link property which can be used to disable or enable
* the fast-path of the given legacy link. The possible values are "true"
* and "false". Note that even when "_disable_fastpath" is set to be
* "false", the fast-path may still not be enabled since there may be
* other mac cleints that request the fast-path to be disabled.
*/
/* ARGSUSED */
static int
softmac_m_setprop(void *arg, const char *name, mac_prop_id_t id,
uint_t valsize, const void *val)
{
softmac_t *softmac = arg;
if (id != MAC_PROP_PRIVATE || strcmp(name, "_disable_fastpath") != 0)
return (ENOTSUP);
if (strcmp(val, "true") == 0)
return (softmac_datapath_switch(softmac, B_TRUE, B_TRUE));
else if (strcmp(val, "false") == 0)
return (softmac_datapath_switch(softmac, B_FALSE, B_TRUE));
else
return (EINVAL);
}
static int
softmac_m_getprop(void *arg, const char *name, mac_prop_id_t id,
uint_t valsize, void *val)
{
softmac_t *softmac = arg;
char *fpstr;
if (id != MAC_PROP_PRIVATE)
return (ENOTSUP);
if (strcmp(name, "_fastpath") == 0) {
mutex_enter(&softmac->smac_fp_mutex);
fpstr = (DATAPATH_MODE(softmac) == SOFTMAC_SLOWPATH) ?
"disabled" : "enabled";
mutex_exit(&softmac->smac_fp_mutex);
} else if (strcmp(name, "_disable_fastpath") == 0) {
fpstr = softmac->smac_fastpath_admin_disabled ?
"true" : "false";
} else if (strcmp(name, "_softmac") == 0) {
fpstr = "true";
} else {
return (ENOTSUP);
}
return (strlcpy(val, fpstr, valsize) >= valsize ? EINVAL : 0);
}
static void
softmac_m_propinfo(void *arg, const char *name, mac_prop_id_t id,
mac_prop_info_handle_t prh)
{
_NOTE(ARGUNUSED(arg));
if (id != MAC_PROP_PRIVATE)
return;
if (strcmp(name, "_fastpath") == 0) {
mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
} else if (strcmp(name, "_disable_fastpath") == 0) {
mac_prop_info_set_default_str(prh, "false");
}
}
int
softmac_hold_device(dev_t dev, dls_dev_handle_t *ddhp)
{
dev_info_t *dip;
char devname[MAXNAMELEN];
softmac_t *softmac;
major_t major;
int ppa, err = 0, inst;
major = getmajor(dev);
ppa = getminor(dev) - 1;
/*
* For GLDv3 devices, look up the device instance using getinfo(9e).
* Otherwise, fall back to the old assumption that inst == ppa. The
* GLDV3_DRV() macro depends on the driver module being loaded, hence
* the call to ddi_hold_driver().
*/
if (ddi_hold_driver(major) == NULL)
return (ENXIO);
if (GLDV3_DRV(major)) {
if ((inst = dev_to_instance(dev)) < 0)
err = ENOENT;
} else {
inst = ppa;
}
ddi_rele_driver(major);
if (err != 0)
return (err);
/*
* First try to hold this device instance to force device to attach
* and ensure that the softmac entry gets created in net_postattach().
*/
if ((dip = ddi_hold_devi_by_instance(major, inst, 0)) == NULL)
return (ENOENT);
/*
* Exclude non-physical network device instances, for example, aggr0.
* Note: this check *must* occur after the dip is held, or else
* NETWORK_PHYSDRV might return false incorrectly. The
* DN_NETWORK_PHYSDRIVER flag used by NETWORK_PHYSDRV() gets set if
* ddi_create_minor_node() is called during the device's attach
* phase.
*/
if (!NETWORK_PHYSDRV(major)) {
ddi_release_devi(dip);
return (ENOENT);
}
/* Now wait for its softmac to be created. */
(void) snprintf(devname, MAXNAMELEN, "%s%d", ddi_major_to_name(major),
ppa);
again:
rw_enter(&softmac_hash_lock, RW_READER);
if (mod_hash_find(softmac_hash, (mod_hash_key_t)devname,
(mod_hash_val_t *)&softmac) != 0) {
/*
* This is rare but possible. It could happen when pre-detach
* routine of the device succeeds. But the softmac will then
* be recreated when device fails to detach (as this device
* is held).
*/
mutex_enter(&smac_global_lock);
rw_exit(&softmac_hash_lock);
cv_wait(&smac_global_cv, &smac_global_lock);
mutex_exit(&smac_global_lock);
goto again;
}
/*
* Bump smac_hold_cnt to prevent device detach.
*/
mutex_enter(&softmac->smac_mutex);
softmac->smac_hold_cnt++;
rw_exit(&softmac_hash_lock);
/*
* Wait till the device is fully attached.
*/
while (softmac->smac_state != SOFTMAC_ATTACH_DONE)
cv_wait(&softmac->smac_cv, &softmac->smac_mutex);
SOFTMAC_STATE_VERIFY(softmac);
if ((err = softmac->smac_attacherr) != 0)
softmac->smac_hold_cnt--;
else
*ddhp = (dls_dev_handle_t)softmac;
mutex_exit(&softmac->smac_mutex);
ddi_release_devi(dip);
return (err);
}
void
softmac_rele_device(dls_dev_handle_t ddh)
{
if (ddh != NULL)
softmac_rele((softmac_t *)ddh);
}
int
softmac_hold(dev_t dev, softmac_t **softmacp)
{
softmac_t *softmac;
char *drv;
mac_handle_t mh;
char mac[MAXNAMELEN];
int err;
if ((drv = ddi_major_to_name(getmajor(dev))) == NULL)
return (EINVAL);
(void) snprintf(mac, MAXNAMELEN, "%s%d", drv, getminor(dev) - 1);
if ((err = mac_open(mac, &mh)) != 0)
return (err);
softmac = (softmac_t *)mac_driver(mh);
mutex_enter(&softmac->smac_mutex);
softmac->smac_hold_cnt++;
mutex_exit(&softmac->smac_mutex);
mac_close(mh);
*softmacp = softmac;
return (0);
}
void
softmac_rele(softmac_t *softmac)
{
mutex_enter(&softmac->smac_mutex);
softmac->smac_hold_cnt--;
mutex_exit(&softmac->smac_mutex);
}