dls_mgmt.c revision da14cebe459d3275048785f25bd869cb09b5307f
/*
* 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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Datalink management routines.
*/
#include <sys/dls_impl.h>
/*
* This vanity name management module is treated as part of the GLD framework
* and we don't hold any GLD framework lock across a call to any mac
* function that needs to acquire the mac perimeter. The hierarchy is
* mac perimeter -> framework locks
*/
static kmem_cache_t *i_dls_devnet_cachep;
static kmutex_t i_dls_mgmt_lock;
static krwlock_t i_dls_devnet_lock;
static mod_hash_t *i_dls_devnet_id_hash;
static mod_hash_t *i_dls_devnet_hash;
/* Upcall door handle */
#define DD_CONDEMNED 0x1
/*
* This structure is used to keep the <linkid, macname> mapping.
*/
typedef struct dls_devnet_s {
char dd_mac[MAXNAMELEN];
} dls_devnet_t;
/*ARGSUSED*/
static int
{
return (0);
}
/*ARGSUSED*/
static void
{
}
/*
* Module initialization and finalization functions.
*/
void
dls_mgmt_init(void)
{
/*
* Create a kmem_cache of dls_devnet_t structures.
*/
sizeof (dls_devnet_t), 0, i_dls_devnet_constructor,
/*
* Create a hash table, keyed by dd_linkid, of dls_devnet_t.
*/
/*
* Create a hash table, keyed by dd_mac
*/
}
void
dls_mgmt_fini(void)
{
}
int
{
int err;
/* handle daemon restart */
if (dls_mgmt_dh != NULL) {
dls_mgmt_dh = NULL;
}
return (err);
}
/*
* Create and associate <link name, linkid> mapping for network devices
* which are already attached before the daemon is started.
*/
if (start)
return (0);
}
static boolean_t
{
extern int sys_shutdown;
if (sys_shutdown) {
return (B_TRUE);
}
return (B_TRUE);
}
/*
* Upcall to the datalink management daemon (dlmgmtd).
*/
static int
{
int err;
int retry = 0;
#define MAXRETRYNUM 3
dh = dls_mgmt_dh;
return (EBADF);
}
for (;;) {
retry++;
SIZE_MAX, 0)) == 0)
break;
/*
* handle door call errors
*/
switch (err) {
case EINTR:
/*
* If the operation which caused this door upcall gets
* interrupted, return directly.
*/
goto done;
case EAGAIN:
/*
* Repeat upcall if the maximum attempt limit has not
* been reached.
*/
if (retry < MAXRETRYNUM) {
break;
}
goto done;
default:
/* A fatal door error */
if (i_dls_mgmt_door_revoked(dh)) {
"dls: dlmgmtd door service revoked\n");
if (retry < MAXRETRYNUM) {
goto retry;
}
}
goto done;
}
}
/*
* The size of the input rbuf was not big enough, so the
* upcall allocated the rbuf itself. If this happens, assume
* that this was an invalid door call request.
*/
goto done;
}
goto done;
}
done:
return (err);
}
/*
* Request the datalink management daemon to create a link with the attributes
* below. Upon success, zero is returned and linkidp contains the linkid for
* the new link; otherwise, an errno is returned.
*
* - dev physical dev_t. required for all physical links,
* including GLDv3 links. It will be used to force the
* attachment of a physical device, hence the
* registration of its mac
* - class datalink class
* - media type media type; DL_OTHER means unknown
* - persist whether to persist the datalink
*/
int
{
int err;
return (EINVAL);
sizeof (retval))) == 0) {
}
return (err);
}
/*
* Request the datalink management daemon to destroy the specified link.
* Returns zero upon success, or an errno upon failure.
*/
int
{
}
/*
* for a physical link. Upon success, get its linkid.
*
* - media type media type
* - novanity whether this physical datalink supports vanity naming.
* physical links that do not use the GLDv3 MAC plugin
* cannot suport vanity naming
*
* This function could fail with ENOENT or EEXIST. Two cases return EEXIST:
*
* 1. A link with devname already exists, but the media type does not match.
* In this case, mediap will bee set to the media type of the existing link.
* 2. A link with devname already exists, but its link name does not match
* the device name, although this link does not support vanity naming.
*/
int
{
int err;
return (EINVAL);
} else if (err == 0) {
}
return (err);
}
/*
* Request the datalink management daemon to get the information for a link.
* Returns zero upon success, or an errno upon failure.
*
* Only fills in information for argument pointers that are non-NULL.
* Note that the link argument is expected to be MAXLINKNAMELEN bytes.
*/
int
{
sizeof (retval))) != 0) {
return (err);
}
return (EINVAL);
return (0);
}
/*
* Request the datalink management daemon to get the linkid for a link.
* Returns a non-zero error code on failure. The linkid argument is only
* set on success (when zero is returned.)
*/
int
{
int err;
sizeof (retval))) == 0) {
}
return (err);
}
{
sizeof (retval)) != 0) {
return (DATALINK_INVALID_LINKID);
}
}
static int
{
int err;
sizeof (retval))) == 0) {
return (EINVAL);
}
return (err);
}
/*
* Note that this function can only get devp successfully for non-VLAN link.
*/
int
{
return (EINVAL);
}
return (0);
}
/*
* Request the datalink management daemon to push in
* all properties associated with the link.
* Returns a non-zero error code on failure.
*/
int
{
int err;
return (err);
}
static void
dls_devnet_prop_task(void *arg)
{
}
/*
* Ensure property loading task is completed.
*/
void
{
}
void
{
}
int
dls_link_t **dlpp)
{
int err;
return (err);
return (err);
}
return (0);
}
void
{
}
/*
* "link" kstats related functions.
*/
/*
* Query the "link" kstats.
*/
static int
{
int err;
if (err != 0)
return (err);
if (err != 0) {
return (err);
}
return (err);
}
/*
* Create the "link" kstats.
*/
static void
{
char link[MAXLINKNAMELEN];
return;
}
return;
}
}
/*
* Destroy the "link" kstats.
*/
static void
{
return;
}
/*
* The link has been renamed. Destroy the old non-legacy kstats ("link kstats")
* and create the new set using the new name.
*/
static void
{
}
return;
}
}
/*
* Associate a linkid with a given link (identified by macname)
*/
static int
{
int err;
goto done;
}
/*
* This might be a physical link that has already
* been created, but which does not have a linkid
* because dlmgmtd was not running when it was created.
*/
goto done;
}
if (class != DATALINK_CLASS_PHYS) {
goto done;
}
goto newphys;
}
if (linkid != DATALINK_INVALID_LINKID) {
(mod_hash_val_t)ddp) == 0);
}
}
err = 0;
done:
return (err);
}
/*
* Disassociate a linkid with a given link (identified by macname)
* This waits until temporary references to the dls_devnet_t are gone.
*/
static int
{
int err;
return (ENOENT);
}
/*
* Make sure downcalls into softmac_create or softmac_destroy from
* devfs don't cv_wait on any devfs related condition for fear of
* deadlock. Return EBUSY if the asynchronous thread started for
* property loading as part of the post attach hasn't yet completed.
*/
return (EBUSY);
}
/*
* Remove this dls_devnet_t from the hash table.
*/
}
if (wait) {
/*
* Wait until all temporary references are released.
*/
} else {
}
return (0);
}
static int
{
int err;
/*
* Hold this link to prevent it being detached in case of a
* physical link.
*/
return (ENOENT);
}
return (ENOENT);
}
if (tmp_hold)
else
return (0);
}
int
{
}
/*
* Hold the vanity naming structure (dls_devnet_t) temporarily. The request to
* delete the dls_devnet_t will wait until the temporary reference is released.
*/
int
{
}
/*
* This funtion is called when a DLS client tries to open a device node.
* devnet_create_rvp->dls_devnet_open()) or a direct /dev node access.
* In both cases, this function bumps up the reference count of the
* dls_devnet_t structure. The reference is held as long as the device node
* is held when the devnet_create_rvp->dls_devnet_open call happens, this
* initial reference is released immediately in devnet_inactive_callback ->
* dls_devnet_close(). (Note that devnet_inactive_callback() is called right
* To undo this function, call dls_devnet_rele()
*/
int
{
char name[MAXNAMELEN];
char *drv;
int err;
return (EINVAL);
/*
* Hold this link to prevent it being detached in case of a
* GLDv3 physical link.
*/
return (ENOENT);
}
return (ENOENT);
}
return (0);
}
void
{
}
static int
{
char drv[MAXLINKNAMELEN];
int err;
/*
* If we failed to get the link's linkid because the dlmgmtd daemon
* has not been started, return ENOENT so that the application can
* fallback to open the /dev node.
*/
return (ENOENT);
return (err);
return (ENOENT);
/*
* If this link:
* (a) is a physical device, (b) this is the first boot, (c) the MAC
* is not registered yet, and (d) we cannot find its linkid, then the
* linkname is the same as the devname.
*
* First filter out invalid names.
*/
return (ENOENT);
return (ENOENT);
/*
* At this time, the MAC should be registered, check its phy_dev using
* the given name.
*/
return (err);
}
return (ENOENT);
}
return (err);
}
int
{
(mod_hash_val_t *)&ddp) != 0) {
return (ENOENT);
}
return (0);
}
/*
* Get linkid for the given dev.
*/
int
{
char macname[MAXNAMELEN];
char *drv;
return (EINVAL);
}
/*
* Get the link's physical dev_t. It this is a VLAN, get the dev_t of the
* link this VLAN is created on.
*/
int
{
int err;
return (err);
return (err);
}
/*
* Handle the renaming requests. There are two rename cases:
*
* 1. Request to rename a valid link (id1) to an non-existent link name
* (id2). In this case id2 is DATALINK_INVALID_LINKID. Just check whether
* id1 is held by any applications.
*
* In this case, the link's kstats need to be updated using the given name.
*
* 2. Request to rename a valid link (id1) to the name of a REMOVED
* physical link (id2). In this case, check that id1 and its associated
* mac is not held by any application, and update the link's linkid to id2.
*
* This case does not change the <link name, linkid> mapping, so the link's
* kstats need to be updated with using name associated the given id2.
*/
int
{
char linkname[MAXLINKNAMELEN];
int err = 0;
/*
* In the second case, id2 must be a REMOVED physical link.
*/
if ((id2 != DATALINK_INVALID_LINKID) &&
return (EEXIST);
}
/*
* Hold id1 to prevent it from being detached (if a physical link).
*/
/*
* The framework does not hold hold locks across calls to the
* mac perimeter, hence enter the perimeter first. This also waits
* for the property loading to finish.
*/
goto done;
goto done;
}
/*
* Return EBUSY if any applications have this link open.
*/
goto done;
}
if (id2 == DATALINK_INVALID_LINKID) {
/* rename mac client name and its flow if exists */
goto done;
goto done;
}
/*
* The second case, check whether the MAC is used by any MAC
* user. This must be a physical link so ddh must not be NULL.
*/
goto done;
}
goto done;
/*
* We release the reference of the MAC which mac_open() is
* holding. Note that this mac will not be unregistered
* because the physical device is held.
*/
/*
* Check if there is any other MAC clients, if not, hold this mac
* exclusively until we are done.
*/
goto done;
/*
* Update the link's linkid.
*/
goto done;
}
if (err != 0) {
goto done;
}
(void) mod_hash_remove(i_dls_devnet_id_hash,
(void) mod_hash_insert(i_dls_devnet_id_hash,
/* load properties for new id */
done:
/*
* Change the name of the kstat based on the new link name.
*/
if (err == 0)
return (err);
}
int
{
int err;
return (err);
if (err != 0)
return (err);
return (0);
}
return (err);
}
/*
* Keep this open reference only if it belonged to the global zone
* and is now assigned to a non-global zone.
*/
/*
* Then release this link if it belonged to an non-global zone
* but is now assigned back to the global zone.
*/
return (0);
}
int
{
int err;
return (err);
return (0);
}
/*
* Access a vanity naming node.
*/
int
{
int err;
return (err);
/*
* Opening a link that does not belong to the current non-global zone
* is not allowed.
*/
return (ENOENT);
}
if (err != 0) {
return (err);
}
if (err != 0) {
return (err);
}
return (0);
}
/*
* Close access to a vanity naming node.
*/
void
{
/*
* One rele for the hold placed in dls_devnet_open, another for
* the hold done just above
*/
}
/*
* critical and no protection is needed.
*/
{
return (updated);
}
int
{
int err;
/*
* Make this association before we call dls_link_hold_create as
* we need to use the linkid to get the user name for the link
* when we create the MAC client.
*/
return (err);
}
return (err);
}
return (err);
}
/*
* Set the linkid of the dls_devnet_t and add it into the i_dls_devnet_id_hash.
* This is called in the case that the dlmgmtd daemon is started later than
* the physical devices get attached, and the linkid is only known after the
* daemon starts.
*/
int
{
}
int
{
int err;
return (err);
if (err == 0)
return (0);
return (err);
}
const char *
{
}
{
}