q3k/linux
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
linux/drivers/net/enic/enic_pp.c
Roopa Prabhu b3abfbd295 enic: Add support for PORT_REQUEST_PREASSOCIATE_RR 
Current enic code only supports ASSOCIATE and DISASSOCIATE port profile
operations. This patch adds enic support for port profile
PORT_REQUEST_PREASSOCIATE_RR operation. The VIC adapter (8021qbh) is capable
of handling port profile requests done in two steps namely PREASSOCIATE_RR
and ASSOCIATE today. The motivation to support PREASSOCIATE_RR comes mainly
from its use as an optimization during VM migration ie, to do resource
reservation on destination host before resources on source host are released.

PREASSOCIATE_RR is a VDP operation and according to the latest at IEEE,
8021qbh will also need to support VDP commands.

In addition to handling the new PORT_REQUEST_PREASSOCIATE_RR operation
this patch also does the below:
- Introduces handlers for PORT_REQUEST operations
- Moves most of the port profile handling code to new files enic_pp.[ch]
- Uses new fw devcmds for port profile operations

Signed-off-by: Roopa Prabhu <roprabhu@cisco.com>
Signed-off-by: David Wang <dwang2@cisco.com>
Signed-off-by: Christian Benvenuti <benve@cisco.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2011-03-30 21:39:26 -07:00

264 lines
6.7 KiB
C
Raw Blame History

/*
* Copyright 2011 Cisco Systems, Inc. All rights reserved.
*
* This program is free software; you may redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/rtnetlink.h>
#include <net/ip.h>
#include "vnic_vic.h"
#include "enic_res.h"
#include "enic.h"
#include "enic_dev.h"
static int enic_set_port_profile(struct enic *enic)
{
struct net_device *netdev = enic->netdev;
struct vic_provinfo *vp;
const u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
const u16 os_type = htons(VIC_GENERIC_PROV_OS_TYPE_LINUX);
char uuid_str[38];
char client_mac_str[18];
u8 *client_mac;
int err;
if (!(enic->pp.set & ENIC_SET_NAME) || !strlen(enic->pp.name))
return -EINVAL;
vp = vic_provinfo_alloc(GFP_KERNEL, oui,
VIC_PROVINFO_GENERIC_TYPE);
if (!vp)
return -ENOMEM;
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_PORT_PROFILE_NAME_STR,
strlen(enic->pp.name) + 1, enic->pp.name);
if (!is_zero_ether_addr(enic->pp.mac_addr))
client_mac = enic->pp.mac_addr;
else
client_mac = netdev->dev_addr;
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_CLIENT_MAC_ADDR,
ETH_ALEN, client_mac);
snprintf(client_mac_str, sizeof(client_mac_str), "%pM", client_mac);
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_CLUSTER_PORT_UUID_STR,
sizeof(client_mac_str), client_mac_str);
if (enic->pp.set & ENIC_SET_INSTANCE) {
sprintf(uuid_str, "%pUB", enic->pp.instance_uuid);
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
sizeof(uuid_str), uuid_str);
}
if (enic->pp.set & ENIC_SET_HOST) {
sprintf(uuid_str, "%pUB", enic->pp.host_uuid);
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_HOST_UUID_STR,
sizeof(uuid_str), uuid_str);
}
VIC_PROVINFO_ADD_TLV(vp,
VIC_GENERIC_PROV_TLV_OS_TYPE,
sizeof(os_type), &os_type);
err = enic_dev_status_to_errno(enic_dev_init_prov2(enic, vp));
add_tlv_failure:
vic_provinfo_free(vp);
return err;
}
static int enic_unset_port_profile(struct enic *enic)
{
int err;
err = enic_vnic_dev_deinit(enic);
if (err)
return enic_dev_status_to_errno(err);
enic_reset_addr_lists(enic);
return 0;
}
static int enic_are_pp_different(struct enic_port_profile *pp1,
struct enic_port_profile *pp2)
{
return strcmp(pp1->name, pp2->name) | !!memcmp(pp1->instance_uuid,
pp2->instance_uuid, PORT_UUID_MAX) |
!!memcmp(pp1->host_uuid, pp2->host_uuid, PORT_UUID_MAX) |
!!memcmp(pp1->mac_addr, pp2->mac_addr, ETH_ALEN);
}
static int enic_pp_preassociate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp);
static int enic_pp_disassociate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp);
static int enic_pp_preassociate_rr(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp);
static int enic_pp_associate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp);
static int (*enic_pp_handlers[])(struct enic *enic,
struct enic_port_profile *prev_state, int *restore_pp) = {
[PORT_REQUEST_PREASSOCIATE] = enic_pp_preassociate,
[PORT_REQUEST_PREASSOCIATE_RR] = enic_pp_preassociate_rr,
[PORT_REQUEST_ASSOCIATE] = enic_pp_associate,
[PORT_REQUEST_DISASSOCIATE] = enic_pp_disassociate,
};
static const int enic_pp_handlers_count =
sizeof(enic_pp_handlers)/sizeof(*enic_pp_handlers);
static int enic_pp_preassociate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp)
{
return -EOPNOTSUPP;
}
static int enic_pp_disassociate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp)
{
return enic_unset_port_profile(enic);
}
static int enic_pp_preassociate_rr(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp)
{
int err;
int active = 0;
if (enic->pp.request != PORT_REQUEST_ASSOCIATE) {
/* If pre-associate is not part of an associate.
We always disassociate first */
err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](enic,
prev_pp, restore_pp);
if (err)
return err;
*restore_pp = 0;
}
*restore_pp = 0;
err = enic_set_port_profile(enic);
if (err)
return err;
/* If pre-associate is not part of an associate. */
if (enic->pp.request != PORT_REQUEST_ASSOCIATE)
err = enic_dev_status_to_errno(enic_dev_enable2(enic, active));
return err;
}
static int enic_pp_associate(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp)
{
int err;
int active = 1;
/* Check if a pre-associate was called before */
if (prev_pp->request != PORT_REQUEST_PREASSOCIATE_RR ||
(prev_pp->request == PORT_REQUEST_PREASSOCIATE_RR &&
enic_are_pp_different(prev_pp, &enic->pp))) {
err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](
enic, prev_pp, restore_pp);
if (err)
return err;
*restore_pp = 0;
}
err = enic_pp_handlers[PORT_REQUEST_PREASSOCIATE_RR](
enic, prev_pp, restore_pp);
if (err)
return err;
*restore_pp = 0;
return enic_dev_status_to_errno(enic_dev_enable2(enic, active));
}
int enic_process_set_pp_request(struct enic *enic,
struct enic_port_profile *prev_pp, int *restore_pp)
{
if (enic->pp.request < enic_pp_handlers_count
&& enic_pp_handlers[enic->pp.request])
return enic_pp_handlers[enic->pp.request](enic,
prev_pp, restore_pp);
else
return -EOPNOTSUPP;
}
int enic_process_get_pp_request(struct enic *enic, int request,
u16 *response)
{
int err, status = ERR_SUCCESS;
switch (request) {
case PORT_REQUEST_PREASSOCIATE_RR:
case PORT_REQUEST_ASSOCIATE:
err = enic_dev_enable2_done(enic, &status);
break;
case PORT_REQUEST_DISASSOCIATE:
err = enic_dev_deinit_done(enic, &status);
break;
default:
return -EINVAL;
}
if (err)
status = err;
switch (status) {
case ERR_SUCCESS:
*response = PORT_PROFILE_RESPONSE_SUCCESS;
break;
case ERR_EINVAL:
*response = PORT_PROFILE_RESPONSE_INVALID;
break;
case ERR_EBADSTATE:
*response = PORT_PROFILE_RESPONSE_BADSTATE;
break;
case ERR_ENOMEM:
*response = PORT_PROFILE_RESPONSE_INSUFFICIENT_RESOURCES;
break;
case ERR_EINPROGRESS:
*response = PORT_PROFILE_RESPONSE_INPROGRESS;
break;
default:
*response = PORT_PROFILE_RESPONSE_ERROR;
break;
}
return 0;
}
Reference in a new issue View git blame Copy permalink