354 lines
8.3 KiB
C
354 lines
8.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
// Copyright 2011 Cisco Systems, Inc. All rights reserved.
|
|
|
|
#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"
|
|
#include "enic_pp.h"
|
|
|
|
/*
|
|
* Checks validity of vf index that came in
|
|
* port profile request
|
|
*/
|
|
int enic_is_valid_pp_vf(struct enic *enic, int vf, int *err)
|
|
{
|
|
if (vf != PORT_SELF_VF) {
|
|
#ifdef CONFIG_PCI_IOV
|
|
if (enic_sriov_enabled(enic)) {
|
|
if (vf < 0 || vf >= enic->num_vfs) {
|
|
*err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
} else {
|
|
*err = -EOPNOTSUPP;
|
|
goto err_out;
|
|
}
|
|
#else
|
|
*err = -EOPNOTSUPP;
|
|
goto err_out;
|
|
#endif
|
|
}
|
|
|
|
if (vf == PORT_SELF_VF && !enic_is_dynamic(enic)) {
|
|
*err = -EOPNOTSUPP;
|
|
goto err_out;
|
|
}
|
|
|
|
*err = 0;
|
|
return 1;
|
|
|
|
err_out:
|
|
return 0;
|
|
}
|
|
|
|
static int enic_set_port_profile(struct enic *enic, int vf)
|
|
{
|
|
struct net_device *netdev = enic->netdev;
|
|
struct enic_port_profile *pp;
|
|
struct vic_provinfo *vp;
|
|
const u8 oui[3] = VIC_PROVINFO_CISCO_OUI;
|
|
const __be16 os_type = htons(VIC_GENERIC_PROV_OS_TYPE_LINUX);
|
|
const u8 *client_mac;
|
|
char uuid_str[38];
|
|
char client_mac_str[18];
|
|
int err;
|
|
|
|
ENIC_PP_BY_INDEX(enic, vf, pp, &err);
|
|
if (err)
|
|
return err;
|
|
|
|
if (!(pp->set & ENIC_SET_NAME) || !strlen(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(pp->name) + 1, pp->name);
|
|
|
|
if (!is_zero_ether_addr(pp->mac_addr)) {
|
|
client_mac = pp->mac_addr;
|
|
} else if (vf == PORT_SELF_VF) {
|
|
client_mac = netdev->dev_addr;
|
|
} else {
|
|
netdev_err(netdev, "Cannot find pp mac address "
|
|
"for VF %d\n", vf);
|
|
err = -EINVAL;
|
|
goto add_tlv_failure;
|
|
}
|
|
|
|
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 (pp->set & ENIC_SET_INSTANCE) {
|
|
sprintf(uuid_str, "%pUB", pp->instance_uuid);
|
|
VIC_PROVINFO_ADD_TLV(vp,
|
|
VIC_GENERIC_PROV_TLV_CLIENT_UUID_STR,
|
|
sizeof(uuid_str), uuid_str);
|
|
}
|
|
|
|
if (pp->set & ENIC_SET_HOST) {
|
|
sprintf(uuid_str, "%pUB", 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);
|
|
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_init_prov2, (u8 *)vp,
|
|
vic_provinfo_size(vp));
|
|
err = enic_dev_status_to_errno(err);
|
|
|
|
add_tlv_failure:
|
|
vic_provinfo_free(vp);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int enic_unset_port_profile(struct enic *enic, int vf)
|
|
{
|
|
int err;
|
|
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_deinit);
|
|
if (err)
|
|
return enic_dev_status_to_errno(err);
|
|
|
|
if (vf == PORT_SELF_VF)
|
|
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) |
|
|
!ether_addr_equal(pp1->mac_addr, pp2->mac_addr);
|
|
}
|
|
|
|
static int enic_pp_preassociate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp);
|
|
static int enic_pp_disassociate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp);
|
|
static int enic_pp_preassociate_rr(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp);
|
|
static int enic_pp_associate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp);
|
|
|
|
static int (*enic_pp_handlers[])(struct enic *enic, int vf,
|
|
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 =
|
|
ARRAY_SIZE(enic_pp_handlers);
|
|
|
|
static int enic_pp_preassociate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int enic_pp_disassociate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp)
|
|
{
|
|
struct net_device *netdev = enic->netdev;
|
|
struct enic_port_profile *pp;
|
|
int err;
|
|
|
|
ENIC_PP_BY_INDEX(enic, vf, pp, &err);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Deregister mac addresses */
|
|
if (!is_zero_ether_addr(pp->mac_addr))
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_del_addr,
|
|
pp->mac_addr);
|
|
else if (vf == PORT_SELF_VF && !is_zero_ether_addr(netdev->dev_addr))
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_del_addr,
|
|
netdev->dev_addr);
|
|
|
|
return enic_unset_port_profile(enic, vf);
|
|
}
|
|
|
|
static int enic_pp_preassociate_rr(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp)
|
|
{
|
|
struct enic_port_profile *pp;
|
|
int err;
|
|
int active = 0;
|
|
|
|
ENIC_PP_BY_INDEX(enic, vf, pp, &err);
|
|
if (err)
|
|
return err;
|
|
|
|
if (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, vf,
|
|
prev_pp, restore_pp);
|
|
if (err)
|
|
return err;
|
|
|
|
*restore_pp = 0;
|
|
}
|
|
|
|
*restore_pp = 0;
|
|
|
|
err = enic_set_port_profile(enic, vf);
|
|
if (err)
|
|
return err;
|
|
|
|
/* If pre-associate is not part of an associate. */
|
|
if (pp->request != PORT_REQUEST_ASSOCIATE) {
|
|
/* Enable device as standby */
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_enable2,
|
|
active);
|
|
err = enic_dev_status_to_errno(err);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
static int enic_pp_associate(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp)
|
|
{
|
|
struct net_device *netdev = enic->netdev;
|
|
struct enic_port_profile *pp;
|
|
int err;
|
|
int active = 1;
|
|
|
|
ENIC_PP_BY_INDEX(enic, vf, pp, &err);
|
|
if (err)
|
|
return err;
|
|
|
|
/* 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, pp))) {
|
|
err = enic_pp_handlers[PORT_REQUEST_DISASSOCIATE](
|
|
enic, vf, prev_pp, restore_pp);
|
|
if (err)
|
|
return err;
|
|
|
|
*restore_pp = 0;
|
|
}
|
|
|
|
err = enic_pp_handlers[PORT_REQUEST_PREASSOCIATE_RR](
|
|
enic, vf, prev_pp, restore_pp);
|
|
if (err)
|
|
return err;
|
|
|
|
*restore_pp = 0;
|
|
|
|
/* Enable device as active */
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_enable2, active);
|
|
err = enic_dev_status_to_errno(err);
|
|
if (err)
|
|
return err;
|
|
|
|
/* Register mac address */
|
|
if (!is_zero_ether_addr(pp->mac_addr))
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_add_addr,
|
|
pp->mac_addr);
|
|
else if (vf == PORT_SELF_VF && !is_zero_ether_addr(netdev->dev_addr))
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic, vnic_dev_add_addr,
|
|
netdev->dev_addr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int enic_process_set_pp_request(struct enic *enic, int vf,
|
|
struct enic_port_profile *prev_pp, int *restore_pp)
|
|
{
|
|
struct enic_port_profile *pp;
|
|
int err;
|
|
|
|
ENIC_PP_BY_INDEX(enic, vf, pp, &err);
|
|
if (err)
|
|
return err;
|
|
|
|
if (pp->request >= enic_pp_handlers_count
|
|
|| !enic_pp_handlers[pp->request])
|
|
return -EOPNOTSUPP;
|
|
|
|
return enic_pp_handlers[pp->request](enic, vf, prev_pp, restore_pp);
|
|
}
|
|
|
|
int enic_process_get_pp_request(struct enic *enic, int vf,
|
|
int request, u16 *response)
|
|
{
|
|
int err, status = ERR_SUCCESS;
|
|
|
|
switch (request) {
|
|
|
|
case PORT_REQUEST_PREASSOCIATE_RR:
|
|
case PORT_REQUEST_ASSOCIATE:
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic,
|
|
vnic_dev_enable2_done, &status);
|
|
break;
|
|
|
|
case PORT_REQUEST_DISASSOCIATE:
|
|
ENIC_DEVCMD_PROXY_BY_INDEX(vf, err, enic,
|
|
vnic_dev_deinit_done, &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;
|
|
}
|