Google Git
Sign in
nest-open-source / manifest_repos / sdk / 298baf23afcd1beb26cd47146293d6ea996a71fc / . / qca-nss-clients / gre / nss_connmgr_gre.c
blob: 4797264f17ef920ed61687f5da6b744c9ce1ffd3 [file] [log] [blame]
/*
**************************************************************************
* Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
* above copyright notice and this permission notice appear in all copies.
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
**************************************************************************
*/
/*
* nss_connnmgr_gre.c
* This file implements client for GRE.
*/
#include <linux/version.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <net/ip_tunnels.h>
#include <net/ip6_tunnel.h>
#include <linux/if_ether.h>
#include <net/gre.h>
#include <net/ip.h>
#include <nss_api_if.h>
#include <nss_dynamic_interface.h>
#include <nss_cmn.h>
#include "nss_connmgr_gre_public.h"
#include "nss_connmgr_gre.h"
#define MAX_RETRY_COUNT 100
#define MAX_WIFI_HEADROOM 66
/*
* GRE connection manager context structure
*/
struct nss_connmgr_gre_context {
struct list_head list; /* List of GRE interface instances */
spinlock_t lock; /* Lock to protect list */
} gre_connmgr_ctx;
/*
* GRE interface instance
*/
struct nss_gre_iface_instance {
struct list_head list; /* List of GRE interface instances */
struct net_device *dev; /* GRE netdevice */
struct nss_connmgr_gre_cfg gre_cfg; /* GRE configuration */
enum nss_connmgr_gre_iftype gre_iftype; /* GRE interface type */
uint32_t inner_ifnum; /* GRE inner dynamic interface */
uint32_t outer_ifnum; /* GRE outer dynamic interface */
};
/*
* Unaligned infra in nss is disabled by default
*/
static bool enable_unalign = 1;
module_param(enable_unalign, bool, 0);
/*
* nss_connmgr_gre_is_gre()
* Check whether device is of type GRE Tap or GRE Tun.
*/
static bool nss_connmgr_gre_is_gre(struct net_device *dev)
{
if ((dev->type == ARPHRD_IPGRE) ||
(dev->type == ARPHRD_IP6GRE) || ((dev->type == ARPHRD_ETHER) &&
(dev->priv_flags_ext & (IFF_EXT_GRE_V4_TAP | IFF_EXT_GRE_V6_TAP)))) {
return true;
}
return false;
}
/*
* nss_connmgr_gre_alloc_instance()
* Allocate GRE interface instance.
*/
static struct nss_gre_iface_instance *nss_connmgr_gre_alloc_instance(struct net_device *dev)
{
struct nss_gre_iface_instance *ngii;
if (!nss_connmgr_gre_is_gre(dev)) {
nss_connmgr_gre_warning("%px: dev is not a GRE interface\n", dev);
return NULL;
}
ngii = kzalloc(sizeof(*ngii), GFP_KERNEL);
if (!ngii)
return NULL;
INIT_LIST_HEAD(&ngii->list);
ngii->dev = dev;
return ngii;
}
/*
* nss_connmgr_gre_free_instance()
* Free GRE interface instance.
*/
static void nss_connmgr_gre_free_instance(struct nss_gre_iface_instance *ngii)
{
spin_lock(&gre_connmgr_ctx.lock);
ngii->dev = NULL;
if (!list_empty(&ngii->list))
list_del(&ngii->list);
spin_unlock(&gre_connmgr_ctx.lock);
kfree(ngii);
}
/*
* nss_connmgr_gre_find_instance()
* Find GRE interface instance from list.
*/
static struct nss_gre_iface_instance *nss_connmgr_gre_find_instance(struct net_device *dev)
{
struct nss_gre_iface_instance *ngii;
if (!nss_connmgr_gre_is_gre(dev)) {
nss_connmgr_gre_warning("%px: dev is not a GRE interface\n", dev);
return NULL;
}
/*
* Check if dev instance is in the list
*/
spin_lock(&gre_connmgr_ctx.lock);
list_for_each_entry(ngii, &gre_connmgr_ctx.list, list) {
if (ngii->dev == dev) {
spin_unlock(&gre_connmgr_ctx.lock);
return ngii;
}
}
spin_unlock(&gre_connmgr_ctx.lock);
return NULL;
}
/*
* nss_connmgr_gre_dev_change_mtu()
* Netdev ops function to modify MTU of netdevice.
*/
static int nss_connmgr_gre_dev_change_mtu(struct net_device *dev, int new_mtu)
{
if (new_mtu < 68 ||
new_mtu > 0xFFF8 - dev->needed_headroom) {
return -EINVAL;
}
dev->mtu = new_mtu;
return 0;
}
/*
* nss_connmgr_gre_dev_init()
* Netdev ops function to intialize netdevice.
*/
static int nss_connmgr_gre_dev_init(struct net_device *dev)
{
int i;
nss_connmgr_gre_priv_t *priv = netdev_priv(dev);
int32_t append = priv->pad_len + priv->gre_hlen;
dev->tstats = alloc_percpu(struct pcpu_sw_netstats);
if (!dev->tstats) {
return -ENOMEM;
}
for_each_possible_cpu(i) {
struct pcpu_sw_netstats *stats;
stats = per_cpu_ptr(dev->tstats, i);
u64_stats_init(&stats->syncp);
}
if ((dev->priv_flags_ext & IFF_EXT_GRE_V4_TAP) || (dev->type == ARPHRD_IPGRE)) {
dev->needed_headroom = sizeof(struct iphdr) + sizeof(struct ethhdr) + MAX_WIFI_HEADROOM + append;
dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - append;
dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA;
dev->hw_features |= NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA;
return 0;
}
/*
* Ipv6
*/
dev->needed_headroom = sizeof(struct ipv6hdr) + sizeof(struct ethhdr) + MAX_WIFI_HEADROOM + append;
dev->mtu = ETH_DATA_LEN - sizeof(struct ipv6hdr) - append;
if (dev->mtu < IPV6_MIN_MTU) {
dev->mtu = IPV6_MIN_MTU;
}
dev->features |= NETIF_F_NETNS_LOCAL;
return 0;
}
/*
* nss_connmgr_gre_dev_uninit()
* Netdev ops function to unintialize netdevice.
*/
static void nss_connmgr_gre_dev_uninit(struct net_device *dev)
{
free_percpu(dev->tstats);
return;
}
/*
* nss_connmgr_gre_dev_xmit()
* Netdev ops function to send packet to NSS.
*/
static netdev_tx_t nss_connmgr_gre_dev_xmit(struct sk_buff *skb, struct net_device *dev)
{
nss_tx_status_t status;
int if_number;
struct nss_ctx_instance *gre_ctx;
nss_connmgr_gre_priv_t *priv = netdev_priv(dev);
if_number = priv->nss_if_number_inner;
if (unlikely(if_number <= 0)) {
nss_connmgr_gre_info("%px: GRE dev is not registered with nss\n", dev);
goto fail;
}
gre_ctx = nss_gre_get_context();
if (unlikely(!gre_ctx)) {
nss_connmgr_gre_info("%px: NSS GRE context not found for if_number %d\n", dev, if_number);
goto fail;
}
/*
* Make room for needed headroom and un-share
* the SKB if it is cloned.
*/
if (skb_cow_head(skb, dev->needed_headroom)) {
nss_connmgr_gre_info("%px: NSS GRE insufficient headroom\n", dev);
goto fail;
}
status = nss_gre_tx_buf(gre_ctx, if_number, skb);
if (unlikely(status != NSS_TX_SUCCESS)) {
nss_connmgr_gre_info("%px: NSS GRE could not send packet to NSS %d\n", dev, if_number);
goto fail;
}
return NETDEV_TX_OK;
fail:
dev->stats.tx_dropped++;
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
/*
* nss_connmgr_gre_get_dev_stats64()
* To get the netdev stats
*/
static struct rtnl_link_stats64 *nss_connmgr_gre_get_dev_stats64(struct net_device *dev,
struct rtnl_link_stats64 *tot)
{
uint64_t rx_packets, rx_bytes, tx_packets, tx_bytes;
unsigned int start;
int i;
for_each_possible_cpu(i) {
const struct pcpu_sw_netstats *tstats = per_cpu_ptr(dev->tstats, i);
do {
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 15, 0))
start = u64_stats_fetch_begin_bh(&tstats->syncp);
#else
start = u64_stats_fetch_begin_irq(&tstats->syncp);
#endif
rx_packets = tstats->rx_packets;
tx_packets = tstats->tx_packets;
rx_bytes = tstats->rx_bytes;
tx_bytes = tstats->tx_bytes;
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 15, 0))
} while (u64_stats_fetch_retry_bh(&tstats->syncp, start));
#else
} while (u64_stats_fetch_retry_irq(&tstats->syncp, start));
#endif
tot->rx_packets += rx_packets;
tot->tx_packets += tx_packets;
tot->rx_bytes += rx_bytes;
tot->tx_bytes += tx_bytes;
tot->rx_dropped = dev->stats.rx_dropped;
tot->tx_dropped = dev->stats.tx_dropped;
}
return tot;
}
#if (LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0))
/*
* nss_connmgr_gre_dev_stats64()
* Netdev ops function to retrieve stats for kernel version < 4.6
*/
static struct rtnl_link_stats64 *nss_connmgr_gre_dev_stats64(struct net_device *dev,
struct rtnl_link_stats64 *tot)
{
return nss_connmgr_gre_get_dev_stats64(dev, tot);
}
#else
/*
* nss_connmgr_gre_dev_stats64()
* Netdev ops function to retrieve stats
*/
static void nss_connmgr_gre_dev_stats64(struct net_device *dev,
struct rtnl_link_stats64 *tot)
{
nss_connmgr_gre_get_dev_stats64(dev, tot);
}
#endif
/*
* nss_connmgr_gre_dev_open()
* Netdev ops function to open netdevice.
*/
int nss_connmgr_gre_dev_open(struct net_device *dev)
{
struct nss_ctx_instance *nss_ctx;
struct nss_gre_msg req;
struct nss_gre_linkup_msg *linkup = &req.msg.linkup;
struct nss_gre_linkdown_msg *linkdown = &req.msg.linkdown;
nss_tx_status_t status;
int32_t inner_if, outer_if;
inner_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (inner_if < 0) {
return -EINVAL;
}
outer_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (outer_if < 0) {
return -EINVAL;
}
nss_ctx = nss_gre_get_context();
memset(&req, 0, sizeof(struct nss_gre_msg));
/*
* Open inner interface
*/
linkup->if_number = inner_if;
nss_gre_msg_init(&req, inner_if, NSS_IF_OPEN, sizeof(struct nss_gre_linkup_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: open failed for inner interface %s", dev, dev->name);
return -EFAULT;
}
/*
* Open outer interface
*/
linkup->if_number = outer_if;
nss_gre_msg_init(&req, outer_if, NSS_IF_OPEN, sizeof(struct nss_gre_linkup_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: open failed for outer interface %s", dev, dev->name);
linkdown->if_number = inner_if;
nss_gre_msg_init(&req, inner_if, NSS_IF_CLOSE, sizeof(struct nss_gre_linkdown_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: close failed for inner interface %s", dev, dev->name);
}
return -EFAULT;
}
netif_start_queue(dev);
return 0;
}
EXPORT_SYMBOL(nss_connmgr_gre_dev_open);
/*
* nss_connmgr_gre_dev_close()
* Netdevice ops function to close netdevice.
*/
int nss_connmgr_gre_dev_close(struct net_device *dev)
{
struct nss_ctx_instance *nss_ctx;
struct nss_gre_msg req;
struct nss_gre_linkdown_msg *linkdown = &req.msg.linkdown;
struct nss_gre_linkup_msg *linkup = &req.msg.linkup;
nss_tx_status_t status;
int32_t inner_if, outer_if;
netif_stop_queue(dev);
inner_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (inner_if < 0) {
nss_connmgr_gre_info("%px: close failed for interface %s, inner interface: %d not valid", dev, dev->name, inner_if);
return -EINVAL;
}
outer_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (outer_if < 0) {
nss_connmgr_gre_info("%px: close failed for interface %s, outer interface: %d not valid", dev, dev->name, inner_if);
return -EINVAL;
}
nss_ctx = nss_gre_get_context();
memset(&req, 0, sizeof(struct nss_gre_msg));
/*
* Close inner interface
*/
linkdown->if_number = inner_if;
nss_gre_msg_init(&req, inner_if, NSS_IF_CLOSE, sizeof(struct nss_gre_linkdown_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: close failed for inner interface %s", dev, dev->name);
return -EFAULT;
}
/*
* Close outer interface
*/
linkdown->if_number = outer_if;
nss_gre_msg_init(&req, outer_if, NSS_IF_CLOSE, sizeof(struct nss_gre_linkdown_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: close failed for outer interface %s", dev, dev->name);
linkup->if_number = inner_if;
nss_gre_msg_init(&req, inner_if, NSS_IF_OPEN, sizeof(struct nss_gre_linkup_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: open failed for inner interface %s", dev, dev->name);
}
return -EFAULT;
}
return 0;
}
EXPORT_SYMBOL(nss_connmgr_gre_dev_close);
/*
* Tap net device ops
*/
static const struct net_device_ops nss_connmgr_gre_tap_ops = {
.ndo_init = nss_connmgr_gre_dev_init,
.ndo_uninit = nss_connmgr_gre_dev_uninit,
.ndo_open = nss_connmgr_gre_dev_open,
.ndo_stop = nss_connmgr_gre_dev_close,
.ndo_set_mac_address = eth_mac_addr,
.ndo_validate_addr = eth_validate_addr,
.ndo_change_mtu = nss_connmgr_gre_dev_change_mtu,
.ndo_start_xmit = nss_connmgr_gre_dev_xmit,
.ndo_get_stats64 = nss_connmgr_gre_dev_stats64,
};
/*
* Tun netdevice ops
*/
static const struct net_device_ops nss_connmgr_gre_tun_ops = {
.ndo_init = nss_connmgr_gre_dev_init,
.ndo_uninit = nss_connmgr_gre_dev_uninit,
.ndo_open = nss_connmgr_gre_dev_open,
.ndo_stop = nss_connmgr_gre_dev_close,
.ndo_change_mtu = nss_connmgr_gre_dev_change_mtu,
.ndo_start_xmit = nss_connmgr_gre_dev_xmit,
.ndo_get_stats64 = nss_connmgr_gre_dev_stats64,
};
/*
* nss_connmgr_gre_tun_setup()
*/
static void nss_connmgr_gre_tun_setup(struct net_device *dev)
{
dev->addr_len = 4;
dev->flags = IFF_NOARP | IFF_POINTOPOINT;
dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
dev->netdev_ops = &nss_connmgr_gre_tun_ops;
}
/*
* nss_connmgr_gre_tap_setup()
*/
static void nss_connmgr_gre_tap_setup(struct net_device *dev)
{
dev->netdev_ops = &nss_connmgr_gre_tap_ops;
eth_hw_addr_random(dev);
}
/*
* nss_connmgr_gre_prepare_config_cmd()
* Retrieve info from netdevie and fill it in config message to NSS.
*/
static int32_t nss_connmgr_gre_prepare_config_cmd(struct net_device *dev,
struct nss_gre_msg *req,
struct net_device **next_dev,
bool hold)
{
struct nss_gre_config_msg *cmsg = &req->msg.cmsg;
if ((dev->type == ARPHRD_ETHER) && (dev->priv_flags_ext & IFF_EXT_GRE_V4_TAP)) {
cmsg->mode = NSS_GRE_MODE_TAP;
cmsg->ip_type = NSS_GRE_IP_IPV4;
if (enable_unalign) {
cmsg->flags |= NSS_GRE_CONFIG_USE_UNALIGNED;
}
return nss_connmgr_gre_v4_get_config(dev, req, next_dev, hold);
}
if ((dev->type == ARPHRD_ETHER) && (dev->priv_flags_ext & IFF_EXT_GRE_V6_TAP)) {
cmsg->mode = NSS_GRE_MODE_TAP;
cmsg->ip_type = NSS_GRE_IP_IPV6;
if (enable_unalign) {
cmsg->flags |= NSS_GRE_CONFIG_USE_UNALIGNED;
}
return nss_connmgr_gre_v6_get_config(dev, req, next_dev, hold);
}
if (dev->type == ARPHRD_IPGRE) {
cmsg->mode = NSS_GRE_MODE_TUN;
cmsg->ip_type = NSS_GRE_IP_IPV4;
return nss_connmgr_gre_v4_get_config(dev, req, next_dev, hold);
}
if (dev->type == ARPHRD_IP6GRE) {
cmsg->mode = NSS_GRE_MODE_TUN;
cmsg->ip_type = NSS_GRE_IP_IPV6;
return nss_connmgr_gre_v6_get_config(dev, req, next_dev, hold);
}
return GRE_ERR_NOT_GRE_NETDEV;
}
/*
* nss_connmgr_gre_tap_inner_exception()
* Exception handler for GRETAP inner device
*
* These are the packets exceptioned after decapsulation,
* and we can send the packet to linux after modifying
* some skb fields.
*/
static void nss_connmgr_gre_tap_inner_exception(struct net_device *dev, struct sk_buff *skb,
__attribute__((unused)) struct napi_struct *napi)
{
struct ethhdr *eth_hdr = (struct ethhdr *)skb->data;
nss_connmgr_gre_trace("%px: eth_hdr->h_proto: %d\n", dev, eth_hdr->h_proto);
if (likely(ntohs(eth_hdr->h_proto) >= ETH_P_802_3_MIN)) {
switch (ntohs(eth_hdr->h_proto)) {
case ETH_P_IP:
case ETH_P_IPV6:
/*
* These are decapped packets.
*/
skb->protocol = eth_type_trans(skb, dev);
netif_receive_skb(skb);
return;
default:
break;
}
}
/*
* These are decapped and exceptioned non IP packets.
*/
skb->protocol = eth_type_trans(skb, dev);
netif_receive_skb(skb);
return;
}
/*
* nss_connmgr_gre_tap_outer_exception()
* Exception handler for GRETAP outer device
*
* These are the packets exceptioned after encapsulation,
* and we need to remove the GRE header of the packet and
* pass it to linux.
*/
static void nss_connmgr_gre_tap_outer_exception(struct net_device *dev, struct sk_buff *skb,
__attribute__((unused)) struct napi_struct *napi)
{
struct ethhdr *eth_hdr;
eth_hdr = (struct ethhdr *)skb->data;
nss_connmgr_gre_trace("%px: eth_hdr->h_proto: %d\n", dev, eth_hdr->h_proto);
if (likely(ntohs(eth_hdr->h_proto) >= ETH_P_802_3_MIN)) {
switch (ntohs(eth_hdr->h_proto)) {
case ETH_P_IP:
return nss_connmgr_gre_tap_v4_outer_exception(dev, skb);
case ETH_P_IPV6:
return nss_connmgr_gre_tap_v6_outer_exception(dev, skb);
default:
nss_connmgr_gre_warning("%px: invalid skb received:%px with protocol: %d. Freeing the skb.\n", dev, skb, ntohs(eth_hdr->h_proto));
dev_kfree_skb_any(skb);
}
}
}
/*
* nss_connmgr_gre_tun_inner_exception()
* Exception handler for GRETUN inner device
*
* These are the packets exceptioned after decapsulation,
* and we can send the packet to linux after modifying
* some skb fields.
*/
static void nss_connmgr_gre_tun_inner_exception(struct net_device *dev, struct sk_buff *skb,
__attribute__((unused)) struct napi_struct *napi)
{
struct iphdr *iph;
iph = (struct iphdr *)skb->data;
switch (iph->version) {
case 4:
skb->protocol = htons(ETH_P_IP);
break;
case 6:
skb->protocol = htons(ETH_P_IPV6);
break;
default:
nss_connmgr_gre_warning("%px: wrong IP version set to skb:%px\n", dev, skb);
dev_kfree_skb_any(skb);
return;
}
skb->pkt_type = PACKET_HOST;
skb->dev = dev;
netif_receive_skb(skb);
}
/*
* nss_connmgr_gre_tun_outer_exception()
* Exception handler for GRETUN outer device
*
* These are the packets exceptioned after encapsulation,
* and we need to remove the GRE header of the packet and
* pass it to linux.
*/
static void nss_connmgr_gre_tun_outer_exception(struct net_device *dev, struct sk_buff *skb,
__attribute__((unused)) struct napi_struct *napi)
{
struct iphdr *iph;
iph = (struct iphdr *)skb->data;
switch (iph->version) {
case 4:
return nss_connmgr_gre_tun_v4_outer_exception(dev, skb);
case 6:
return nss_connmgr_gre_tun_v6_outer_exception(dev, skb);
default:
nss_connmgr_gre_warning("%px: wrong IP version set to skb:%px\n", dev, skb);
dev_kfree_skb_any(skb);
break;
}
}
/*
* nss_connmgr_gre_rx_pkt()
* GRE Tap function to receive packet from NSS.
*/
static void nss_connmgr_gre_rx_pkt(struct net_device *dev, struct sk_buff *skb,
__attribute__((unused)) struct napi_struct *napi)
{
skb->dev = dev;
skb->protocol = eth_type_trans(skb, dev);
netif_receive_skb(skb);
}
/*
* nss_connmgr_gre_event_receive()
* Event Callback to receive events from NSS
*/
static void nss_connmgr_gre_event_receive(void *if_ctx, struct nss_gre_msg *tnlmsg)
{
struct net_device *dev = if_ctx;
struct nss_cmn_node_stats *stats = &tnlmsg->msg.sstats.node_stats;
struct pcpu_sw_netstats *tstats;
enum nss_dynamic_interface_type interface_type;
switch (tnlmsg->cm.type) {
case NSS_GRE_MSG_SESSION_STATS:
interface_type = nss_dynamic_interface_get_type(nss_gre_get_context(), tnlmsg->cm.interface);
tstats = this_cpu_ptr(dev->tstats);
u64_stats_update_begin(&tstats->syncp);
if (interface_type == NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER) {
tstats->tx_packets += stats->tx_packets;
tstats->tx_bytes += stats->tx_bytes;
} else if (interface_type == NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER) {
tstats->rx_packets += stats->rx_packets;
tstats->rx_bytes += stats->rx_bytes;
}
u64_stats_update_end(&tstats->syncp);
dev->stats.rx_dropped += nss_cmn_rx_dropped_sum(stats);
break;
case NSS_GRE_MSG_BASE_STATS:
break;
default:
nss_connmgr_gre_info("%px: Unknown Event from NSS\n", dev);
break;
}
}
/*
* nss_connmgr_gre_make_name()
* Generate a name for netdevice if user does not provide one.
*/
static void nss_connmgr_gre_make_name(struct nss_connmgr_gre_cfg *cfg, char *name)
{
switch (cfg->mode) {
case GRE_MODE_TUN:
strlcpy(name, "tun-%d", IFNAMSIZ);
break;
case GRE_MODE_TAP:
strlcpy(name, "tap-%d", IFNAMSIZ);
break;
default:
break;
}
}
/*
* __nss_connmgr_gre_create_interface()
* Creates GRE Tap/Tun netdevice and configure GRE node in NSS.
* This should be called after acquiring rtnl_lock().
*/
static struct net_device *__nss_connmgr_gre_create_interface(struct nss_connmgr_gre_cfg *cfg,
enum nss_connmgr_gre_err_codes *err_code)
{
struct nss_ctx_instance *nss_ctx;
struct net_device *dev = NULL;
struct net_device *next_dev_inner = NULL;
struct net_device *next_dev_outer = NULL;
struct nss_gre_iface_instance *ngii;
struct nss_gre_msg req;
struct nss_gre_config_msg *cmsg = &req.msg.cmsg;
nss_connmgr_gre_priv_t *priv;
nss_tx_status_t status;
uint32_t features = 0;
int32_t inner_if, outer_if;
char name[IFNAMSIZ] = {0};
int ret = -1, retry, next_if_num_inner = 0, next_if_num_outer = 0;
if (cfg->name) {
strlcpy(name, cfg->name, IFNAMSIZ);
} else {
nss_connmgr_gre_make_name(cfg, name);
}
switch (cfg->mode) {
case GRE_MODE_TUN:
#if (LINUX_VERSION_CODE < KERNEL_VERSION(3, 17, 0))
dev = alloc_netdev(sizeof(nss_connmgr_gre_priv_t), name, nss_connmgr_gre_tun_setup);
#else
dev = alloc_netdev(sizeof(nss_connmgr_gre_priv_t), name, NET_NAME_UNKNOWN, nss_connmgr_gre_tun_setup);
#endif
if (!dev) {
nss_connmgr_gre_warning("Allocation of netdev failed\n");
*err_code = GRE_ERR_ALLOC_NETDEV;
return NULL;
}
if (cfg->is_ipv6) {
dev->type = ARPHRD_IP6GRE;
ret = nss_connmgr_gre_v6_set_config(dev, cfg);
} else {
dev->type = ARPHRD_IPGRE;
ret = nss_connmgr_gre_v4_set_config(dev, cfg);
}
break;
case GRE_MODE_TAP:
dev = alloc_etherdev(sizeof(nss_connmgr_gre_priv_t));
if (!dev) {
nss_connmgr_gre_warning("Allocation of netdev failed\n");
*err_code = GRE_ERR_ALLOC_NETDEV;
return NULL;
}
nss_connmgr_gre_tap_setup(dev);
if (cfg->is_ipv6) {
dev->priv_flags_ext |= IFF_EXT_GRE_V6_TAP;
ret = nss_connmgr_gre_v6_set_config(dev, cfg);
} else {
dev->priv_flags_ext |= IFF_EXT_GRE_V4_TAP;
ret = nss_connmgr_gre_v4_set_config(dev, cfg);
}
break;
default:
nss_connmgr_gre_warning("Please Specify gre mode\n");
*err_code = GRE_ERR_INVALID_MODE;
goto release_ref;
}
if (ret) {
nss_connmgr_gre_warning("%px: gre interface configuration failed\n", dev);
*err_code = ret;
goto release_ref;
}
/*
* Set name
*/
memcpy(dev->name, name, IFNAMSIZ);
/*
* Create config cmd for acceleration engine
*/
memset(&req, 0, sizeof(struct nss_gre_msg));
ret = nss_connmgr_gre_prepare_config_cmd(dev, &req, &next_dev_inner, true);
if (ret) {
nss_connmgr_gre_warning("%px: gre get config failed\n", dev);
*err_code = ret;
goto release_ref;
}
/*
* Replace MAC addr and next node with user provided entries.
*/
if (cfg->use_mac_hdr) {
memcpy(cmsg->src_mac, cfg->src_mac, ETH_ALEN);
memcpy(cmsg->dest_mac, cfg->dest_mac, ETH_ALEN);
cmsg->flags |= NSS_GRE_CONFIG_SET_MAC;
}
/*
* If next_dev is NULL, then the set MAC
* flag can not be set. Because the packet
* will be forwarded to ipv4_rx/ipv6_rx
*/
if (!cfg->next_dev) {
cmsg->flags &= ~NSS_GRE_CONFIG_SET_MAC;
}
/*
* By now, we should have valid MAC addresses
*/
if (!is_valid_ether_addr((const u8 *)cmsg->src_mac) ||
!is_valid_ether_addr((const u8 *)cmsg->dest_mac)) {
nss_connmgr_gre_warning("%px: Could not find MAC address for src/dest IP\n", dev);
*err_code = GRE_ERR_INVALID_MAC;
goto release_ref;
}
/*
* Configure the inner nexthop ifnum
*/
if (cfg->next_dev) {
/*
* Release hold on GRE inner's nexthop that we have found,
* since it has been passed explicitly via the cfg
*/
if (next_dev_inner) {
dev_put(next_dev_inner);
}
dev_hold(cfg->next_dev);
/*
* TODO: Use the dynamic interface type for the inner's nexthop, in addition to the next_dev.
*/
next_if_num_inner = nss_cmn_get_interface_number_by_dev(cfg->next_dev);
next_dev_inner = cfg->next_dev;
if (next_if_num_inner < 0) {
nss_connmgr_gre_warning("%px: Next dev inner device= %s is not registered with ae engine\n",
dev, cfg->next_dev->name);
*err_code = GRE_ERR_NEXT_NODE_UNREG_IN_AE;
goto release_ref;
}
cmsg->flags |= NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
}
/*
* Configure the outer nexthop ifnum
*/
if (cfg->next_dev_outer) {
dev_hold(cfg->next_dev_outer);
/*
* Verify if dynamic interface type is in range.
*/
if (cfg->outer_nss_if_type >= NSS_DYNAMIC_INTERFACE_TYPE_MAX) {
nss_connmgr_gre_warning("%px: invalid cfg, outer nexthop type %d is not in range\n",
dev, cfg->outer_nss_if_type);
goto release_ref;
}
next_if_num_outer = nss_cmn_get_interface_number_by_dev_and_type(cfg->next_dev_outer, cfg->outer_nss_if_type);
next_dev_outer = cfg->next_dev_outer;
if (next_if_num_outer < 0) {
nss_connmgr_gre_warning("%px: Next dev outer device %s with dynamic if num %d not registered with NSS\n",
dev, cfg->next_dev_outer->name, next_if_num_outer);
*err_code = GRE_ERR_NEXT_NODE_UNREG_IN_AE;
goto release_ref;
}
/*
* Get the NSS ctx for the outer next hop
*/
nss_ctx = nss_dynamic_interface_get_nss_ctx_by_type(cfg->outer_nss_if_type);
if (!nss_ctx) {
nss_connmgr_gre_warning("Could not get NSS context for type : %d\n", cfg->outer_nss_if_type);
goto release_ref;
}
/*
* Append the core-id for the outer next hop ifnum
*/
next_if_num_outer = nss_cmn_append_core_id(nss_ctx, next_if_num_outer);
if (!next_if_num_outer) {
nss_connmgr_gre_warning("%px: Could not get interface number with core ID for outer nexthop device %s with core ID.\n",
nss_ctx, next_dev_outer->name);
goto release_ref;
}
cmsg->flags |= NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
}
/*
* By now, we should have a valid next node for either inner or outer
*/
if (!(cmsg->flags & NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE)) {
nss_connmgr_gre_warning("%px: Next dev is not available\n", dev);
*err_code = GRE_ERR_NO_NEXT_NETDEV;
goto release_ref;
}
if (cfg->add_padding) {
cmsg->flags |= NSS_GRE_CONFIG_SET_PADDING;
}
if (cfg->copy_metadata) {
cmsg->flags |= NSS_GRE_CONFIG_COPY_METADATA;
cmsg->metadata_size = sizeof(struct nss_wifi_append_statsv2_metahdr);
}
/*
* Set per packet DSCP configuration if needed
*/
if (cfg->dscp_valid) {
cmsg->flags |= NSS_GRE_CONFIG_DSCP_VALID;
}
/*
* Register net_device
*/
ret = register_netdevice(dev);
if (ret) {
*err_code = GRE_ERR_NETDEV_REG_FAILED;
nss_connmgr_gre_warning("%px: Netdevice registration failed\n", dev);
goto release_ref;
}
/*
* Create GRE interface instance
*/
ngii = nss_connmgr_gre_alloc_instance(dev);
if (!ngii) {
nss_connmgr_gre_warning("%px: GRE interfacen intance creation failed\n", dev);
*err_code = GRE_ERR_ALLOC_GRE_INSTANCE;
goto unregister_netdev;
}
/*
* Create nss outer dynamic interface
*/
outer_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (outer_if < 0) {
nss_connmgr_gre_warning("%px: Request interface number failed\n", dev);
*err_code = GRE_ERR_DYNMAIC_IFACE_CREATE;
goto free_gre_instance;
}
ngii->outer_ifnum = outer_if;
priv = (nss_connmgr_gre_priv_t *)netdev_priv(dev);
priv->next_dev_outer = next_dev_outer;
/*
* Create nss inner dynamic interface
*/
inner_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (inner_if < 0) {
nss_connmgr_gre_warning("%px: Request interface number failed\n", dev);
*err_code = GRE_ERR_DYNMAIC_IFACE_CREATE;
goto free_gre_instance;
}
ngii->inner_ifnum = inner_if;
priv->next_dev_inner = next_dev_inner;
priv->nss_if_number_inner = inner_if;
/*
* Register outer gre tunnel with NSS
*/
nss_ctx = nss_gre_register_if(outer_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER,
nss_connmgr_gre_rx_pkt,
nss_connmgr_gre_event_receive,
dev,
features);
if (!nss_ctx) {
nss_connmgr_gre_info("%px: nss_register_gre_if failed\n", dev);
*err_code = GRE_ERR_GRE_IFACE_REG;
goto dealloc_inner_node;
}
/*
* Register inner gre tunnel with NSS
*/
nss_ctx = nss_gre_register_if(inner_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER,
nss_connmgr_gre_rx_pkt,
nss_connmgr_gre_event_receive,
dev,
features);
if (!nss_ctx) {
nss_connmgr_gre_info("%px: nss_register_gre_if failed\n", dev);
*err_code = GRE_ERR_GRE_IFACE_REG;
goto dealloc_inner_node;
}
nss_connmgr_gre_info("%px: nss_register_gre_if() custom successful. nss_ctx = %px. inner_if: %d, outer_if: %d\n", dev, nss_ctx, inner_if, outer_if);
/*
* Send encap config to AE
*/
cmsg->flags &= ~NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
/*
* Configure nexthop to inner node if available
*/
if (next_if_num_inner) {
cmsg->next_node_if_num = next_if_num_inner;
cmsg->flags |= NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
}
cmsg->sibling_if_num = outer_if;
nss_gre_msg_init(&req, inner_if, NSS_GRE_MSG_ENCAP_CONFIGURE, sizeof(struct nss_gre_config_msg), NULL, NULL);
nss_connmgr_gre_info("%px: NSS_GRE_MSG_ENCAP_CONFIGURE:: nss_ctx = %px, flags:0x%x, ikey:0x%x, okey:0x%x, mode:%x, next_node_if_num:%u, sibling_if_num:%u, ttl:%u, tos:%u, metadata_size:%u\n",
dev, nss_ctx, cmsg->flags, cmsg->ikey, cmsg->okey, cmsg->mode, cmsg->next_node_if_num, cmsg->sibling_if_num, cmsg->ttl, cmsg->tos, cmsg->metadata_size);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
*err_code = GRE_ERR_AE_CONFIG_FAILED;
nss_connmgr_gre_info("%px: Send Encap config to AE failed\n", next_dev_inner);
goto unregister_nss_interface;
}
/*
* Send decap config to AE
*/
cmsg->flags &= ~NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
/*
* Configure nexthop to outer node if available
*/
if (next_if_num_outer) {
cmsg->next_node_if_num = next_if_num_outer;
cmsg->flags |= NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE;
}
cmsg->sibling_if_num = inner_if;
nss_gre_msg_init(&req, outer_if, NSS_GRE_MSG_DECAP_CONFIGURE, sizeof(struct nss_gre_config_msg), NULL, NULL);
nss_connmgr_gre_info("%px: NSS_GRE_MSG_DECAP_CONFIGURE:: nss_ctx = %px, flags:0x%x, ikey:0x%x, okey:0x%x, mode:%x, next_node_if_num:%u, sibling_if_num:%u, ttl:%u, tos:%u, metadata_size:%u\n",
dev, nss_ctx, cmsg->flags, cmsg->ikey, cmsg->okey, cmsg->mode, cmsg->next_node_if_num, cmsg->sibling_if_num, cmsg->ttl, cmsg->tos, cmsg->metadata_size);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
*err_code = GRE_ERR_AE_CONFIG_FAILED;
nss_connmgr_gre_info("%px: Send decap config to AE failed\n", next_dev_outer);
goto unregister_nss_interface;
}
/*
* Set vap next hop if next_dev is configured
* TODO: Do this in a more generic manner by checking the dynamic interface type of next_dev
*/
if (cfg->next_dev) {
ret = nss_connmgr_gre_set_wifi_next_hop(cfg->next_dev);
if (ret) {
nss_connmgr_gre_info("%px: Setting next hop of wifi vdev failed\n", dev);
*err_code = ret;
goto unregister_nss_interface;
}
}
memcpy(&ngii->gre_cfg, cfg, sizeof(*cfg));
ngii->gre_iftype = NSS_CONNMGR_GRE_IFTYPE_CUSTOM_GRE;
spin_lock(&gre_connmgr_ctx.lock);
list_add(&ngii->list, &gre_connmgr_ctx.list);
spin_unlock(&gre_connmgr_ctx.lock);
/*
* Success
*/
*err_code = GRE_SUCCESS;
return dev;
unregister_nss_interface:
nss_gre_unregister_if(inner_if);
nss_gre_unregister_if(outer_if);
retry = 0;
dealloc_inner_node:
status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (status != NSS_TX_SUCCESS) {
if (++retry <= MAX_RETRY_COUNT) {
goto dealloc_inner_node;
}
nss_connmgr_gre_error("%px: Fatal Error, Unable to dealloc the node[%d] in the NSS FW!\n", dev, inner_if);
}
retry = 0;
dealloc_outer_node:
status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (status != NSS_TX_SUCCESS) {
if (++retry <= MAX_RETRY_COUNT) {
goto dealloc_outer_node;
}
nss_connmgr_gre_error("%px: Fatal Error, Unable to dealloc the node[%d] in the NSS FW!\n", dev, outer_if);
}
free_gre_instance:
nss_connmgr_gre_free_instance(ngii);
unregister_netdev:
unregister_netdevice(dev);
release_ref:
if (next_dev_inner) {
dev_put(next_dev_inner);
}
if (next_dev_outer) {
dev_put(next_dev_outer);
}
return dev;
}
/*
* nss_connmgr_gre_destroy_inner_interface()
* Destroy inner GRE Tap/Tun interface.
*/
static enum nss_connmgr_gre_err_codes nss_connmgr_gre_destroy_inner_interface(struct net_device *dev, int interface_num)
{
struct nss_gre_msg req;
struct nss_gre_deconfig_msg *dmsg;
nss_tx_status_t status;
int retry = 0;
memset(&req, 0, sizeof(struct nss_gre_msg));
dmsg = &req.msg.dmsg;
dmsg->if_number = interface_num;
deconfig_inner:
nss_gre_msg_init(&req, interface_num, NSS_GRE_MSG_ENCAP_DECONFIGURE, sizeof(struct nss_gre_deconfig_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_gre_get_context(), &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre instance deconfigure command failed, interface_num = %d\n", dev, interface_num);
if (++retry <= MAX_RETRY_COUNT) {
goto deconfig_inner;
}
nss_connmgr_gre_error("%px: Fatal Error, failed to send GRE deconfig command to NSS\n", dev);
return GRE_ERR_AE_DECONFIG_FAILED;
}
retry = 0;
nss_gre_unregister_if(interface_num);
dealloc_inner:
status = nss_dynamic_interface_dealloc_node(interface_num, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre dealloc node failure for interface_num = %d\n", dev, interface_num);
if (++retry <= MAX_RETRY_COUNT) {
goto dealloc_inner;
}
nss_connmgr_gre_error("%px: Fatal Error, failed to send GRE dealloc command to NSS\n", dev);
return GRE_ERR_DYNMAIC_IFACE_DESTROY;
}
return GRE_SUCCESS;
}
/*
* nss_connmgr_gre_destroy_outer_interface()
* Destroy outer GRE Tap/Tun interface.
*/
static enum nss_connmgr_gre_err_codes nss_connmgr_gre_destroy_outer_interface(struct net_device *dev, int interface_num)
{
struct nss_gre_msg req;
struct nss_gre_deconfig_msg *dmsg;
nss_tx_status_t status;
int retry = 0;
memset(&req, 0, sizeof(struct nss_gre_msg));
dmsg = &req.msg.dmsg;
dmsg->if_number = interface_num;
deconfig_outer:
nss_gre_msg_init(&req, interface_num, NSS_GRE_MSG_DECAP_DECONFIGURE, sizeof(struct nss_gre_deconfig_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_gre_get_context(), &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre instance deconfigure command failed, interface_num = %d\n", dev, interface_num);
if (++retry <= MAX_RETRY_COUNT) {
goto deconfig_outer;
}
nss_connmgr_gre_error("%px: Fatal Error, failed to send GRE deconfig command to NSS\n", dev);
return GRE_ERR_AE_DECONFIG_FAILED;
}
nss_gre_unregister_if(interface_num);
retry = 0;
dealloc_outer:
status = nss_dynamic_interface_dealloc_node(interface_num, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre dealloc node failure for inner_if = %d\n", dev, interface_num);
if (++retry <= MAX_RETRY_COUNT) {
goto dealloc_outer;
}
nss_connmgr_gre_error("%px: Fatal Error, failed to send GRE dealloc command to NSS\n", dev);
return GRE_ERR_DYNMAIC_IFACE_DESTROY;
}
return GRE_SUCCESS;
}
/*
* __nss_connmgr_gre_destroy_interface()
* Destroy GRE Tap/Tun netdevice. Acquire rtnl_lock() before calling this
* function.
*/
static enum nss_connmgr_gre_err_codes __nss_connmgr_gre_destroy_interface(struct net_device *dev)
{
struct nss_gre_iface_instance *ngii;
nss_connmgr_gre_priv_t *priv;
enum nss_connmgr_gre_err_codes ret;
netif_tx_disable(dev);
ngii = nss_connmgr_gre_find_instance(dev);
if(!ngii) {
nss_connmgr_gre_warning("%px: GRE interface instance is not found.\n", dev);
return GRE_ERR_NO_GRE_INSTANCE;
}
/*
* Decrement ref to next_dev
*/
priv = (nss_connmgr_gre_priv_t *)netdev_priv(dev);
if (priv->next_dev_inner) {
dev_put(priv->next_dev_inner);
}
if (priv->next_dev_outer) {
dev_put(priv->next_dev_outer);
}
ret = nss_connmgr_gre_destroy_inner_interface(dev, ngii->inner_ifnum);
if (ret != GRE_SUCCESS) {
nss_connmgr_gre_warning("%px: failed to destroy inner interface: %d\n", dev, ngii->inner_ifnum);
return ret;
}
ret = nss_connmgr_gre_destroy_outer_interface(dev, ngii->outer_ifnum);
if (ret != GRE_SUCCESS) {
nss_connmgr_gre_warning("%px: failed to destroy outer interface: %d\n", dev, ngii->outer_ifnum);
return ret;
}
nss_connmgr_gre_info("%px: deleted gre instance, inner_if = %d outer_if = %d\n",
dev, ngii->inner_ifnum, ngii->outer_ifnum);
nss_connmgr_gre_free_instance(ngii);
unregister_netdevice(dev);
return GRE_SUCCESS;
}
/*
* nss_connmgr_gre_validate_config()
* No support for CSUM, SEQ number.
*/
static bool nss_connmgr_gre_validate_config(struct nss_connmgr_gre_cfg *cfg)
{
/*
* TODO:Disallow key for standard GRE TAP/TUN.
*/
if (cfg->iseq_valid || cfg->oseq_valid || cfg->icsum_valid || cfg->ocsum_valid) {
nss_connmgr_gre_info("Bad config, seq and csum are not supported.\n");
return false;
}
/*
* Validate DSCP and ToS inherit flags.
*/
if (cfg->dscp_valid && cfg->tos_inherit) {
nss_connmgr_gre_info("Bad config, Both DSCP and ToS inherit flags are set.\n");
return false;
}
return true;
}
/*
* nss_connmgr_gre_dev_up()
* Netdevice notifier call back to configure NSS for GRE Tap/Tun device.
*/
static int nss_connmgr_gre_dev_up(struct net_device *dev)
{
struct nss_gre_msg req;
struct nss_gre_config_msg *cmsg = &req.msg.cmsg;
int inner_if, outer_if;
uint32_t features = 0;
struct nss_ctx_instance *nss_ctx = NULL;
nss_tx_status_t status;
struct net_device *next_dev = NULL;
/*
* If GRE interface instance is found return, dev is Custom GRE interface type.
*/
if (nss_connmgr_gre_find_instance(dev)) {
nss_connmgr_gre_info("%px: Custom GRE interface is up.\n", dev);
return NOTIFY_DONE;
}
/*
* Create config cmd for acceleration engine
*/
memset(&req, 0, sizeof(struct nss_gre_msg));
if (nss_connmgr_gre_prepare_config_cmd(dev, &req, &next_dev, false)) {
nss_connmgr_gre_info("%px: gre tunnel get config failed\n", dev);
return NOTIFY_DONE;
}
/*
* Ignore set_mac and next_dev flags for generic GRE
*/
cmsg->flags &= ~(NSS_GRE_CONFIG_SET_MAC | NSS_GRE_CONFIG_NEXT_NODE_AVAILABLE);
/*
* Create nss outer dynamic interface
*/
outer_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (outer_if < 0) {
nss_connmgr_gre_warning("%px: Request interface number failed\n", dev);
return NOTIFY_DONE;
}
/*
* Create nss inner dynamic interface
*/
inner_if = nss_dynamic_interface_alloc_node(NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (inner_if < 0) {
nss_connmgr_gre_warning("%px: Request interface number failed\n", dev);
goto dealloc_outer;
}
/*
* Register gre inner/outer interface with NSS
*/
if ((dev->type == ARPHRD_IPGRE) || (dev->type == ARPHRD_IP6GRE)) {
/*
* GRE Tunnel mode
*/
nss_ctx = nss_gre_register_if(inner_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER,
nss_connmgr_gre_tun_inner_exception,
nss_connmgr_gre_event_receive,
dev,
features);
if (!nss_ctx) {
nss_connmgr_gre_info("%px: nss_register_gre_if failed\n", dev);
goto dealloc_inner;
}
nss_ctx = nss_gre_register_if(outer_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER,
nss_connmgr_gre_tun_outer_exception,
nss_connmgr_gre_event_receive,
dev,
features);
} else {
/*
* GRE Tap mode
*/
nss_ctx = nss_gre_register_if(inner_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER,
nss_connmgr_gre_tap_inner_exception,
nss_connmgr_gre_event_receive,
dev,
features);
if (!nss_ctx) {
nss_connmgr_gre_info("%px: nss_register_gre_if failed\n", dev);
goto dealloc_inner;
}
nss_ctx = nss_gre_register_if(outer_if,
NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER,
nss_connmgr_gre_tap_outer_exception,
nss_connmgr_gre_event_receive,
dev,
features);
}
if (!nss_ctx) {
nss_connmgr_gre_info("%px: nss_register_gre_if failed\n", dev);
goto unregister_inner;
}
nss_connmgr_gre_info("%px: nss_register_gre_if() standard successful. nss_ctx = %px. inner_if: %d, outer_if: %d\n", dev, nss_ctx, inner_if, outer_if);
/*
* Send configure command for inner interface
*/
cmsg->sibling_if_num = outer_if;
nss_gre_msg_init(&req, inner_if, NSS_GRE_MSG_ENCAP_CONFIGURE, sizeof(struct nss_gre_config_msg), NULL, NULL);
nss_connmgr_gre_info("%px: NSS_GRE_MSG_ENCAP_CONFIGURE:: nss_ctx = %px, flags:0x%x, ikey:0x%x, okey:0x%x, mode:%x, next_node_if_num:%u, sibling_if_num:%u, ttl:%u, tos:%u, metadata_size:%u\n",
dev, nss_ctx, cmsg->flags, cmsg->ikey, cmsg->okey, cmsg->mode, cmsg->next_node_if_num, cmsg->sibling_if_num, cmsg->ttl, cmsg->tos, cmsg->metadata_size);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_warning("%px: nss gre std configure command error %d\n", dev, status);
goto unregister_outer;
}
/*
* Send configure command for outer interface
*/
cmsg->sibling_if_num = inner_if;
nss_gre_msg_init(&req, outer_if, NSS_GRE_MSG_DECAP_CONFIGURE, sizeof(struct nss_gre_config_msg), NULL, NULL);
nss_connmgr_gre_info("%px: NSS_GRE_MSG_DECAP_CONFIGURE:: nss_ctx = %px, flags:0x%x, ikey:0x%x, okey:0x%x, mode:%x, next_node_if_num:%u, sibling_if_num:%u, ttl:%u, tos:%u, metadata_size:%u\n",
dev, nss_ctx, cmsg->flags, cmsg->ikey, cmsg->okey, cmsg->mode, cmsg->next_node_if_num, cmsg->sibling_if_num, cmsg->ttl, cmsg->tos, cmsg->metadata_size);
status = nss_gre_tx_msg_sync(nss_ctx, &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_warning("%px: nss gre std configure command error %d\n", dev, status);
goto unregister_outer;
}
/*
* Open the netdev to accept packets
*/
if (nss_connmgr_gre_dev_open(dev)) {
nss_connmgr_gre_warning("%px: nss gre std device up command failed %d\n", dev, status);
goto unregister_outer;
}
return NOTIFY_DONE;
unregister_outer:
nss_gre_unregister_if(outer_if);
unregister_inner:
nss_gre_unregister_if(inner_if);
dealloc_inner:
status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", dev, inner_if);
}
dealloc_outer:
status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_warning("%px: Unable to dealloc the node[%d] in the NSS fw!\n", dev, outer_if);
}
return NOTIFY_DONE;
}
/*
* nss_connmgr_gre_dev_down()
* Netdevice notifier call back to destroy GRE interface in NSS.
*/
static int nss_connmgr_gre_dev_down(struct net_device *dev)
{
struct nss_gre_msg req;
struct nss_gre_deconfig_msg *dmsg;
int inner_if, outer_if;
nss_tx_status_t status;
/*
* If GRE interface instance is found return, dev is Custom GRE interface type.
*/
if (nss_connmgr_gre_find_instance(dev)) {
nss_connmgr_gre_info("%px: Custom GRE interface is down.\n", dev);
return NOTIFY_DONE;
}
/*
* Check if gre inner interface is registered with NSS
*/
inner_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (inner_if < 0) {
nss_connmgr_gre_info("%px: Net device is not registered with nss\n", dev);
return NOTIFY_DONE;
}
outer_if = nss_cmn_get_interface_number_by_dev_and_type(dev, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (outer_if < 0) {
nss_connmgr_gre_info("%px: Net device is not registered with nss\n", dev);
return NOTIFY_DONE;
}
memset(&req, 0, sizeof(struct nss_gre_msg));
dmsg = &req.msg.dmsg;
dmsg->if_number = inner_if;
nss_gre_msg_init(&req, inner_if, NSS_GRE_MSG_ENCAP_DECONFIGURE, sizeof(struct nss_gre_deconfig_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_gre_get_context(), &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre instance deconfigure command fo encap failed, inner_if = %d\n", dev, inner_if);
return NOTIFY_DONE;
}
dmsg->if_number = outer_if;
nss_gre_msg_init(&req, outer_if, NSS_GRE_MSG_DECAP_DECONFIGURE, sizeof(struct nss_gre_deconfig_msg), NULL, NULL);
status = nss_gre_tx_msg_sync(nss_gre_get_context(), &req);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre instance deconfigure command for decap failed, inner_if = %d\n", dev, inner_if);
return NOTIFY_DONE;
}
if (nss_connmgr_gre_dev_close(dev)) {
nss_connmgr_gre_info("%px: gre instance device close command failed, inner_if = %d\n", dev, inner_if);
return NOTIFY_DONE;
}
nss_gre_unregister_if(inner_if);
status = nss_dynamic_interface_dealloc_node(inner_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_INNER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre dealloc node failure for inner_if = %d\n", dev, inner_if);
return NOTIFY_DONE;
}
nss_connmgr_gre_info("%px: deleting gre instance, inner_if = %d\n", dev, inner_if);
nss_gre_unregister_if(outer_if);
status = nss_dynamic_interface_dealloc_node(outer_if, NSS_DYNAMIC_INTERFACE_TYPE_GRE_OUTER);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: gre dealloc node failure for outer_if = %d\n", dev, outer_if);
return NOTIFY_DONE;
}
nss_connmgr_gre_info("%px: deleted gre instance, outer_if = %d\n", dev, outer_if);
return NOTIFY_DONE;
}
/*
* nss_connmgr_gre_dev_event()
* Netdevice notifier call back function.
*/
static int nss_connmgr_gre_dev_event(struct notifier_block *nb,
unsigned long event, void *dev)
{
struct net_device *netdev;
netdev = netdev_notifier_info_to_dev(dev);
switch (event) {
case NETDEV_UP:
return nss_connmgr_gre_dev_up(netdev);
case NETDEV_DOWN:
return nss_connmgr_gre_dev_down(netdev);
default:
break;
}
return NOTIFY_DONE;
}
/*
* Linux Net device Notifier
*/
static struct notifier_block nss_connmgr_gre_notifier = {
.notifier_call = nss_connmgr_gre_dev_event,
};
/*
* nss_connmgr_gre_dev_init_module()
* Tunnel gre module init function
*/
static int __init nss_connmgr_gre_dev_init_module(void)
{
#ifdef CONFIG_OF
/*
* If the node is not compatible, don't do anything.
*/
if (!of_find_node_by_name(NULL, "nss-common")) {
return 0;
}
#endif
INIT_LIST_HEAD(&gre_connmgr_ctx.list);
spin_lock_init(&gre_connmgr_ctx.lock);
register_netdevice_notifier(&nss_connmgr_gre_notifier);
return 0;
}
/*
* nss_connmgr_gre_exit_module
* Tunnel gre module exit function
*/
static void __exit nss_connmgr_gre_exit_module(void)
{
struct nss_gre_iface_instance *ngii, *n;
#ifdef CONFIG_OF
/*
* If the node is not compatible, don't do anything.
*/
if (!of_find_node_by_name(NULL, "nss-common")) {
return;
}
#endif
/*
* Unregister GRE interfaces created and delete interface
* instances.
*/
list_for_each_entry_safe(ngii, n, &gre_connmgr_ctx.list, list) {
rtnl_lock();
__nss_connmgr_gre_destroy_interface(ngii->dev);
rtnl_unlock();
}
unregister_netdevice_notifier(&nss_connmgr_gre_notifier);
}
/*
* nss_connmgr_gre_set_next_hop()
* Function changes next hop of wifi_vdev to NSS_GRE_INTERFACE
*/
int nss_connmgr_gre_set_wifi_next_hop(struct net_device *wifi_vdev)
{
nss_tx_status_t status;
void *ctx;
int ifnumber;
if (!wifi_vdev) {
nss_connmgr_gre_info("wifi interface is NULL\n");
return GRE_ERR_NO_NEXT_NETDEV;
}
ifnumber = nss_cmn_get_interface_number_by_dev(wifi_vdev);
if (ifnumber < 0) {
nss_connmgr_gre_info("%px: wifi interface is not recognized by NSS\n", wifi_vdev);
return GRE_ERR_NEXT_NODE_UNREG_IN_AE;
}
ctx = nss_wifi_get_context();
status = nss_wifi_vdev_set_next_hop(ctx, ifnumber, NSS_GRE_INTERFACE);
if (status != NSS_TX_SUCCESS) {
nss_connmgr_gre_info("%px: wifi drv api failed to set next hop\n", wifi_vdev);
return GRE_ERR_AE_SET_NEXT_HOP;
}
return GRE_SUCCESS;
}
/*
* nss_connmgr_gre_get_hlen()
* Calculates GRE header length
*/
uint32_t nss_connmgr_gre_get_hlen(struct nss_connmgr_gre_cfg *cfg)
{
uint32_t size = 4; /* minimum size of GRE packet */
if (cfg->okey_valid) {
size += 4;
}
if (cfg->oseq_valid) {
size += 4;
}
if (cfg->ocsum_valid) {
size += 4;
}
return size;
}
/*
* nss_connmgr_gre_set_gre_flags()
* Map User configured flags to tunnel specific flag.
*/
void nss_connmgr_gre_set_gre_flags(struct nss_connmgr_gre_cfg *cfg,
uint16_t *o_flags, uint16_t *i_flags)
{
if (cfg->ikey_valid) {
*i_flags |= TUNNEL_KEY;
}
if (cfg->okey_valid) {
*o_flags |= TUNNEL_KEY;
}
if (cfg->iseq_valid) {
*i_flags |= TUNNEL_SEQ;
}
if (cfg->oseq_valid) {
*o_flags |= TUNNEL_SEQ;
}
if (cfg->icsum_valid) {
*i_flags |= TUNNEL_CSUM;
}
if (cfg->ocsum_valid) {
*o_flags |= TUNNEL_CSUM;
}
}
/*
* nss_connmgr_gre_get_nss_config_flags()
* Map tunnel specific flags to NSS flags.
*/
uint32_t nss_connmgr_gre_get_nss_config_flags(uint16_t o_flags, uint16_t i_flags,
uint8_t tos, uint8_t ttl,
uint16_t frag_off)
{
uint32_t gre_flags = 0;
if (i_flags & TUNNEL_KEY) {
gre_flags |= NSS_GRE_CONFIG_IKEY_VALID;
}
if (o_flags & TUNNEL_KEY) {
gre_flags |= NSS_GRE_CONFIG_OKEY_VALID;
}
if (i_flags & TUNNEL_SEQ) {
gre_flags |= NSS_GRE_CONFIG_ISEQ_VALID;
}
if (o_flags & TUNNEL_SEQ) {
gre_flags |= NSS_GRE_CONFIG_OSEQ_VALID;
}
if (i_flags & TUNNEL_CSUM) {
gre_flags |= NSS_GRE_CONFIG_ICSUM_VALID;
}
if (o_flags & TUNNEL_CSUM) {
gre_flags |= NSS_GRE_CONFIG_OCSUM_VALID;
}
if (tos & 0x1) {
gre_flags |= NSS_GRE_CONFIG_TOS_INHERIT;
}
if (!ttl) {
gre_flags |= NSS_GRE_CONFIG_TTL_INHERIT;
}
if (frag_off == htons(IP_DF)) {
gre_flags |= NSS_GRE_CONFIG_SET_DF;
}
return gre_flags;
}
/*
* nss_connmgr_gre_destroy_interface()
* User API to delete interface
*/
enum nss_connmgr_gre_err_codes nss_connmgr_gre_destroy_interface(struct net_device *dev)
{
enum nss_connmgr_gre_err_codes ret;
if (!dev) {
nss_connmgr_gre_info("Please specifiy valid interface to be deleted\n");
return GRE_ERR_NO_NETDEV;
}
if (in_interrupt()) {
nss_connmgr_gre_info("%px: nss_connmgr_gre_destroy_interface() called in interrupt context\n", dev);
return GRE_ERR_IN_INTERRUPT_CTX;
}
rtnl_lock();
ret = __nss_connmgr_gre_destroy_interface(dev);
rtnl_unlock();
/*
* free_netdev() should be called outside of rtnl lock
*/
if (!ret) {
free_netdev(dev);
}
return ret;
}
EXPORT_SYMBOL(nss_connmgr_gre_destroy_interface);
/*
* nss_connmgr_gre_create_interface()
* User API to create gre standard interface
*/
struct net_device *nss_connmgr_gre_create_interface(struct nss_connmgr_gre_cfg *cfg,
enum nss_connmgr_gre_err_codes *err_code)
{
struct net_device *dev;
if ((!cfg) || (!err_code)) {
nss_connmgr_gre_info("parameter to this function should not be NULL\n");
return NULL;
}
if (in_interrupt()) {
nss_connmgr_gre_info("nss_connmgr_gre_create_interface() called in interrupt context\n");
*err_code = GRE_ERR_IN_INTERRUPT_CTX;
return NULL;
}
if (!nss_connmgr_gre_validate_config(cfg)) {
*err_code = GRE_ERR_UNSUPPORTED_CFG;
return NULL;
}
rtnl_lock();
dev = __nss_connmgr_gre_create_interface(cfg, err_code);
rtnl_unlock();
if (*err_code == GRE_SUCCESS) {
return dev;
}
if (dev) {
free_netdev(dev);
}
return NULL;
}
EXPORT_SYMBOL(nss_connmgr_gre_create_interface);
module_init(nss_connmgr_gre_dev_init_module);
module_exit(nss_connmgr_gre_exit_module);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("NSS gre offload manager");