vsw_switching.c revision f0ca1d9a12d54d304791bc74525e2010ca924726
/*
* 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.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/sysmacros.h>
#include <sys/ethernet.h>
#include <sys/machsystm.h>
#include <sys/mac_ether.h>
#include <sys/mach_descrip.h>
#include <sys/vio_mailbox.h>
#include <sys/vnet_mailbox.h>
#include <sys/vnet_common.h>
#include <sys/vio_util.h>
/* Switching setup routines */
void vsw_setup_switching_timeout(void *arg);
int vsw_setup_switching(vsw_t *);
static int vsw_setup_layer2(vsw_t *);
static int vsw_setup_layer3(vsw_t *);
/* Forwarding database (FDB) routines */
void vsw_del_mcst_port(vsw_port_t *);
void vsw_del_mcst_vsw(vsw_t *);
/* Support functions */
/*
* Functions imported from other files.
*/
extern int vsw_get_hw_maddr(vsw_t *);
/*
* Tunables used in this file.
*/
extern int vsw_setup_switching_delay;
/*
* Timeout routine to setup switching mode:
* vsw_setup_switching() is invoked from vsw_attach() or vsw_update_md_prop()
* initially. If it fails and the error is EAGAIN, then this timeout handler
* is started to retry vsw_setup_switching(). vsw_setup_switching() is retried
* until we successfully finish it; or the returned error is not EAGAIN.
*/
void
vsw_setup_switching_timeout(void *arg)
{
int rv;
return;
if (rv == 0) {
/*
* Successfully setup switching mode.
* Program unicst, mcst addrs of vsw
* interface and ports in the physdev.
*/
}
/*
* Reschedule timeout() if the error is EAGAIN and the
* timeout is still enabled. For errors other than EAGAIN,
* we simply return without rescheduling timeout().
*/
vswp->swtmout_id =
goto exit;
}
/* timeout handler completed */
vswp->swtmout_id = 0;
exit:
}
/*
* Cancel the timeout handler to setup switching mode.
*/
void
{
if (tid != 0) {
/* signal timeout handler to stop */
vswp->swtmout_id = 0;
} else {
}
vswp->mac_open_retries = 0;
}
/*
* Setup the required switching mode.
* This routine is invoked from vsw_attach() or vsw_update_md_prop()
* initially. If it fails and the error is EAGAIN, then a timeout handler
* is started to retry vsw_setup_switching(), until it successfully finishes;
* or the returned error is not EAGAIN.
*
* Returns:
* 0 on success.
* EAGAIN if retry is needed.
* 1 on all other failures.
*/
int
{
int i, rv = 1;
/*
* Select best switching mode.
* Note that we start from the saved smode_idx. This is done as
* this routine can be called from the timeout handler to retry
* setting up a specific mode. Currently only the function which
* physical device is not available yet, causing retries.
*/
case VSW_LAYER2:
case VSW_LAYER2_PROMISC:
break;
case VSW_LAYER3:
break;
default:
break;
}
break;
/* all other errors(rv != 0): continue & select the next mode */
rv = 1;
}
} else if (rv == 0) {
}
return (rv);
}
/*
* Setup for layer 2 switching.
*
* Returns:
* 0 on success.
* EAGAIN if retry is needed.
* EIO on all other failures.
*/
static int
{
int rv;
if (rv == 0) {
/*
* Physical device name is NULL, which is
* required for layer 2.
*/
return (EIO);
}
if (rv != 0) {
}
return (rv);
}
/*
* Verify that underlying device can support multiple
* unicast mac addresses.
*/
if (rv != 0) {
goto exit_error;
}
}
/*
* Attempt to link into the MAC layer so we can get
* and send packets out over the physical adapter.
*/
if (rv != 0) {
/*
* Registration with the MAC layer has failed,
* so return error so that can fall back to next
* prefered switching method.
*/
goto exit_error;
}
return (0);
return (EIO);
}
static int
{
return (0);
}
/*
* Switch the given ethernet frame when operating in layer 2 mode.
*
* vswp: pointer to the vsw instance
* mp: pointer to chain of ethernet frame(s) to be switched
* caller: identifies the source of this frame as:
* 1. VSW_VNETPORT - a vsw port (connected to a vnet).
* 2. VSW_PHYSDEV - the physical ethernet device
* 3. VSW_LOCALDEV - vsw configured as a virtual interface
* arg: argument provided by the caller.
* 1. for VNETPORT - pointer to the corresponding vsw_port_t.
* 2. for PHYSDEV - NULL
* 3. for LOCALDEV - pointer to to this vsw_t(self)
*/
void
{
struct ether_header *ehp;
/*
* PERF: rather than breaking up the chain here, scan it
* to find all mblks heading to same destination and then
* pass that sub-chain to the lower transmit functions.
*/
/* process the chain of packets */
while (bp) {
/*
* If destination is VSW_LOCALDEV (vsw as an eth
* interface) and if the device is up & running,
* send the packet up the stack on this host.
* If the virtual interface is down, drop the packet.
*/
if (caller != VSW_LOCALDEV) {
} else {
}
continue;
}
if (port) {
/*
* Mark the port as in-use before releasing the lockrw.
*/
/*
* If plumbed and in promisc mode then copy msg
* and send up the stack.
*/
/*
* If the destination is in FDB, the packet
* should be forwarded to the correponding
* vsw_port (connected to a vnet device -
* VSW_VNETPORT)
*/
/*
* Decrement use count in port.
*/
} else {
/*
* Destination not in FDB.
*
* If the destination is broadcast or
* multicast forward the packet to all
* (VNETPORTs, PHYSDEV, LOCALDEV),
* except the caller.
*/
if (IS_BROADCAST(ehp)) {
} else if (IS_MULTICAST(ehp)) {
} else {
/*
* If the destination is unicast, and came
* from either a logical network device or
* the switch itself when it is plumbed, then
* send it out on the physical device and also
* up the stack if the logical interface is
* in promiscious mode.
*
* NOTE: The assumption here is that if we
* cannot find the destination in our fdb, its
* a unicast address, and came from either a
* vnet or down the stack (when plumbed) it
* must be destinded for an ethernet device
* outside our ldoms.
*/
if (caller == VSW_VNETPORT) {
/* promisc check copy etc */
!= NULL) {
"phys dev", __func__);
}
} else if (caller == VSW_PHYSDEV) {
/*
* Pkt seen because card in promisc
* mode. Send up stack if plumbed in
* promisc mode, else drop it.
*/
} else if (caller == VSW_LOCALDEV) {
/*
* Pkt came down the stack, send out
* over physical device.
*/
!= NULL) {
"phys dev", __func__);
}
}
}
}
}
}
/*
* Switch ethernet frame when in layer 3 mode (i.e. using IP
* layer to do the routing).
*
* There is a large amount of overlap between this function and
* vsw_switch_l2_frame. At some stage we need to revisit and refactor
* both these functions.
*/
void
{
struct ether_header *ehp;
/*
* In layer 3 mode should only ever be switching packets
* between IP layer and vnet devices. So make sure thats
* who is invoking us.
*/
return;
}
/* process the chain of packets */
while (bp) {
if (port) {
/*
* Mark the port as in-use before releasing the lockrw.
*/
/*
* Decrement ref count.
*/
} else {
/*
* Destination not in FDB
*
* If the destination is broadcast or
* multicast forward the packet to all
* (VNETPORTs, PHYSDEV, LOCALDEV),
* except the caller.
*/
if (IS_BROADCAST(ehp)) {
} else if (IS_MULTICAST(ehp)) {
} else {
/*
* Unicast pkt from vnet that we don't have
* an FDB entry for, so must be destinded for
* the outside world. Attempt to send up to the
* IP layer to allow it to deal with it.
*/
if (caller == VSW_VNETPORT) {
}
}
}
}
}
/*
* Forward the ethernet frame to all ports (VNETPORTs, PHYSDEV, LOCALDEV),
* except the caller (port on which frame arrived).
*/
static int
{
int skip_port = 0;
/*
* Broadcast message from inside ldoms so send to outside
* world if in either of layer 2 modes.
*/
if (nmp) {
"consisting of %ld bytes of data for"
}
}
}
if (caller == VSW_VNETPORT)
skip_port = 1;
/*
* Broadcast message from other vnet (layer 2 or 3) or outside
* world (layer 2 only), send up stack if plumbed.
*/
}
/* send it to all VNETPORTs */
/*
* Caution ! - don't reorder these two checks as arg
* will be NULL if the caller is PHYSDEV. skip_port is
* only set if caller is VNETPORT.
*/
continue;
} else {
if (nmp) {
/* Find tail */
count++;
}
/*
* The plist->lockrw is protecting the
* portp from getting destroyed here.
* So, no ref_cnt is incremented here.
*/
} else {
}
}
}
return (0);
}
/*
* Forward pkts to any devices or interfaces which have registered
* an interest in them (i.e. multicast groups).
*/
static int
{
/*
* Convert address to hash table key
*/
/*
* If pkt came from either a vnet or down the stack (if we are
* plumbed) and we are in layer 2 mode, then we send the pkt out
* over the physical adapter, and then check to see if any other
* vnets are interested in it.
*/
if (nmp) {
"%ld bytes of data for physical device",
}
}
}
(mod_hash_val_t *)&entp) != 0) {
} else {
/*
* Send to list of devices associated with this address...
*/
/* dont send to ourselves */
if ((caller == VSW_VNETPORT) &&
continue;
} else if ((caller == VSW_LOCALDEV) &&
__func__);
continue;
}
if (nmp) {
/* Find tail */
count++;
}
/*
* The vswp->mfdbrw is protecting the
* portp from getting destroyed here.
* So, no ref_cnt is incremented here.
*/
count);
}
} else {
}
}
}
/*
* If the pkt came from either a vnet or from physical device,
* and if we havent already sent the pkt up the stack then we
* and in promisc mode).
*/
if ((check_if) &&
}
return (0);
}
/*
* Add an entry into FDB, for the given mac address and port_id.
* Returns 0 on success, 1 on failure.
*
* Lock protecting FDB must be held by calling process.
*/
int
{
/*
* Note: duplicate keys will be rejected by mod_hash.
*/
(mod_hash_val_t)port) != 0) {
return (1);
}
return (0);
}
/*
* Remove an entry from FDB.
* Returns 0 on success, 1 on failure.
*/
int
{
return (0);
}
/*
* Search fdb for a given mac address.
* Returns pointer to the entry if found, else returns NULL.
*/
static vsw_port_t *
{
(mod_hash_val_t *)&port) != 0) {
return (NULL);
}
return (port);
}
/*
* Add or remove multicast address(es).
*
* Returns 0 on success, 1 on failure.
*/
int
{
int i;
/*
* Convert address into form that can be used
* as hash table key.
*/
/*
*/
/*
* Update the list of multicast
* addresses contained within the
* port structure to include this new
* one.
*/
__func__);
(void) vsw_del_mcst(vswp,
return (1);
}
/*
* Program the address into HW. If the addr
* has already been programmed then the MAC
* just increments a ref counter (which is
* used when the address is being deleted)
*/
"unable to add multicast "
"address: %s\n",
ether_sprintf((void *)
(void) vsw_del_mcst(vswp,
sizeof (*mcst_p));
return (1);
}
}
} else {
"address 0x%llx for port %ld",
return (1);
}
} else {
/*
* Delete an entry from the multicast hash
* table and update the address list
* appropriately.
*/
port->p_instance);
/*
* Remove the address from HW. The address
* will actually only be removed once the ref
* count within the MAC layer has dropped to
* zero. I.e. we can safely call this fn even
* if other ports are interested in this
* address.
*/
"unable to remove mcast "
"address: %s\n",
ether_sprintf((void *)
sizeof (*mcst_p));
return (1);
}
}
} else {
"addr 0x%llx for port %ld",
return (1);
}
}
}
return (0);
}
/*
* Add a new multicast entry.
*
* Search hash table based on address. If match found then
* update associated val (which is chain of ports), otherwise
*/
int
{
int dup = 0;
int rv = 0;
if (devtype == VSW_VNETPORT) {
/*
* Being invoked from a vnet.
*/
} else {
/*
* We are being invoked via the m_multicst mac entry
* point.
*/
}
(mod_hash_val_t *)&ment) != 0) {
/* address not currently in table */
(mod_hash_val_t)ment) != 0) {
rv = 1;
} else {
}
} else {
/*
* Address in table. Check to see if specified port
* is already associated with the address. If not add
* it now.
*/
if (devtype == VSW_VNETPORT) {
"found for portid %ld and key "
"0x%llx", __func__,
addr);
} else {
}
rv = 1;
dup = 1;
break;
}
}
/*
* Port not on list so add it to end now.
*/
if (0 == dup) {
}
}
return (rv);
}
/*
* Remove a multicast entry from the hashtable.
*
* Search hash table based on address. If match found, scan
* list of ports associated with address. If specified port
* found remove it from list.
*/
int
{
if (devtype == VSW_VNETPORT) {
} else {
}
(mod_hash_val_t *)&ment) != 0) {
return (1);
}
if (devtype == VSW_VNETPORT) {
} else {
}
/*
* head of list, if no other element is in
* list then destroy this entry, otherwise
* just replace it with updated value.
*/
} else {
}
} else {
/*
* Not head of list, no need to do
* replacement, just adjust list pointers.
*/
}
break;
}
}
return (1);
return (0);
}
/*
* Port is being deleted, but has registered an interest in one
* or more multicast groups. Using the list of addresses maintained
* within the port structure find the appropriate entry in the hash
* table and remove this port from the list of interested ports.
*/
void
{
/*
* Remove the address from HW. The address
* will actually only be removed once the ref
* count within the MAC layer has dropped to
* zero. I.e. we can safely call this fn even
* if other ports are interested in this
* address.
*/
}
}
}
/*
* This vsw instance is detaching, but has registered an interest in one
* or more multicast groups. Using the list of addresses maintained
* within the vsw structure find the appropriate entry in the hash
* table and remove this instance from the list of interested ports.
*/
void
{
}
}
static uint32_t
{
struct ether_header *behp;
/* process the chain of packets */
while (bp) {
} else {
}
} else {
}
count++;
} else {
}
}
return (count);
}
static mblk_t *
{
return (NULL);
}
}
return (nmp);
}