Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
0002 /* Copyright (C) 2015-2018 Netronome Systems, Inc. */
0003 
0004 #include <linux/bitfield.h>
0005 #include <linux/netdevice.h>
0006 #include <linux/skbuff.h>
0007 #include <linux/workqueue.h>
0008 #include <net/dst_metadata.h>
0009 
0010 #include "main.h"
0011 #include "../nfp_net.h"
0012 #include "../nfp_net_repr.h"
0013 #include "./cmsg.h"
0014 
0015 static struct nfp_flower_cmsg_hdr *
0016 nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
0017 {
0018     return (struct nfp_flower_cmsg_hdr *)skb->data;
0019 }
0020 
0021 struct sk_buff *
0022 nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
0023               enum nfp_flower_cmsg_type_port type, gfp_t flag)
0024 {
0025     struct nfp_flower_cmsg_hdr *ch;
0026     struct sk_buff *skb;
0027 
0028     size += NFP_FLOWER_CMSG_HLEN;
0029 
0030     skb = nfp_app_ctrl_msg_alloc(app, size, flag);
0031     if (!skb)
0032         return NULL;
0033 
0034     ch = nfp_flower_cmsg_get_hdr(skb);
0035     ch->pad = 0;
0036     ch->version = NFP_FLOWER_CMSG_VER1;
0037     ch->type = type;
0038     skb_put(skb, size);
0039 
0040     return skb;
0041 }
0042 
0043 struct sk_buff *
0044 nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
0045 {
0046     struct nfp_flower_cmsg_mac_repr *msg;
0047     struct sk_buff *skb;
0048 
0049     skb = nfp_flower_cmsg_alloc(app, struct_size(msg, ports, num_ports),
0050                     NFP_FLOWER_CMSG_TYPE_MAC_REPR, GFP_KERNEL);
0051     if (!skb)
0052         return NULL;
0053 
0054     msg = nfp_flower_cmsg_get_data(skb);
0055     memset(msg->reserved, 0, sizeof(msg->reserved));
0056     msg->num_ports = num_ports;
0057 
0058     return skb;
0059 }
0060 
0061 void
0062 nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
0063                  unsigned int nbi, unsigned int nbi_port,
0064                  unsigned int phys_port)
0065 {
0066     struct nfp_flower_cmsg_mac_repr *msg;
0067 
0068     msg = nfp_flower_cmsg_get_data(skb);
0069     msg->ports[idx].idx = idx;
0070     msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
0071     msg->ports[idx].nbi_port = nbi_port;
0072     msg->ports[idx].phys_port = phys_port;
0073 }
0074 
0075 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
0076                 unsigned int mtu, bool mtu_only)
0077 {
0078     struct nfp_flower_cmsg_portmod *msg;
0079     struct sk_buff *skb;
0080 
0081     skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
0082                     NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
0083     if (!skb)
0084         return -ENOMEM;
0085 
0086     msg = nfp_flower_cmsg_get_data(skb);
0087     msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
0088     msg->reserved = 0;
0089     msg->info = carrier_ok;
0090 
0091     if (mtu_only)
0092         msg->info |= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;
0093 
0094     msg->mtu = cpu_to_be16(mtu);
0095 
0096     nfp_ctrl_tx(repr->app->ctrl, skb);
0097 
0098     return 0;
0099 }
0100 
0101 int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
0102 {
0103     struct nfp_flower_cmsg_portreify *msg;
0104     struct sk_buff *skb;
0105 
0106     skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
0107                     NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
0108                     GFP_KERNEL);
0109     if (!skb)
0110         return -ENOMEM;
0111 
0112     msg = nfp_flower_cmsg_get_data(skb);
0113     msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
0114     msg->reserved = 0;
0115     msg->info = cpu_to_be16(exists);
0116 
0117     nfp_ctrl_tx(repr->app->ctrl, skb);
0118 
0119     return 0;
0120 }
0121 
0122 static bool
0123 nfp_flower_process_mtu_ack(struct nfp_app *app, struct sk_buff *skb)
0124 {
0125     struct nfp_flower_priv *app_priv = app->priv;
0126     struct nfp_flower_cmsg_portmod *msg;
0127 
0128     msg = nfp_flower_cmsg_get_data(skb);
0129 
0130     if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
0131         return false;
0132 
0133     spin_lock_bh(&app_priv->mtu_conf.lock);
0134     if (!app_priv->mtu_conf.requested_val ||
0135         app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) ||
0136         be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
0137         /* Not an ack for requested MTU change. */
0138         spin_unlock_bh(&app_priv->mtu_conf.lock);
0139         return false;
0140     }
0141 
0142     app_priv->mtu_conf.ack = true;
0143     app_priv->mtu_conf.requested_val = 0;
0144     wake_up(&app_priv->mtu_conf.wait_q);
0145     spin_unlock_bh(&app_priv->mtu_conf.lock);
0146 
0147     return true;
0148 }
0149 
0150 static void
0151 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
0152 {
0153     struct nfp_flower_cmsg_portmod *msg;
0154     struct net_device *netdev;
0155     bool link;
0156 
0157     msg = nfp_flower_cmsg_get_data(skb);
0158     link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;
0159 
0160     rtnl_lock();
0161     rcu_read_lock();
0162     netdev = nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
0163     rcu_read_unlock();
0164     if (!netdev) {
0165         nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
0166                      be32_to_cpu(msg->portnum));
0167         rtnl_unlock();
0168         return;
0169     }
0170 
0171     if (link) {
0172         u16 mtu = be16_to_cpu(msg->mtu);
0173 
0174         netif_carrier_on(netdev);
0175 
0176         /* An MTU of 0 from the firmware should be ignored */
0177         if (mtu)
0178             dev_set_mtu(netdev, mtu);
0179     } else {
0180         netif_carrier_off(netdev);
0181     }
0182     rtnl_unlock();
0183 }
0184 
0185 static void
0186 nfp_flower_cmsg_portreify_rx(struct nfp_app *app, struct sk_buff *skb)
0187 {
0188     struct nfp_flower_priv *priv = app->priv;
0189     struct nfp_flower_cmsg_portreify *msg;
0190     bool exists;
0191 
0192     msg = nfp_flower_cmsg_get_data(skb);
0193 
0194     rcu_read_lock();
0195     exists = !!nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
0196     rcu_read_unlock();
0197     if (!exists) {
0198         nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
0199                      be32_to_cpu(msg->portnum));
0200         return;
0201     }
0202 
0203     atomic_inc(&priv->reify_replies);
0204     wake_up(&priv->reify_wait_queue);
0205 }
0206 
0207 static void
0208 nfp_flower_cmsg_merge_hint_rx(struct nfp_app *app, struct sk_buff *skb)
0209 {
0210     unsigned int msg_len = nfp_flower_cmsg_get_data_len(skb);
0211     struct nfp_flower_cmsg_merge_hint *msg;
0212     struct nfp_fl_payload *sub_flows[2];
0213     int err, i, flow_cnt;
0214 
0215     msg = nfp_flower_cmsg_get_data(skb);
0216     /* msg->count starts at 0 and always assumes at least 1 entry. */
0217     flow_cnt = msg->count + 1;
0218 
0219     if (msg_len < struct_size(msg, flow, flow_cnt)) {
0220         nfp_flower_cmsg_warn(app, "Merge hint ctrl msg too short - %d bytes but expect %zd\n",
0221                      msg_len, struct_size(msg, flow, flow_cnt));
0222         return;
0223     }
0224 
0225     if (flow_cnt != 2) {
0226         nfp_flower_cmsg_warn(app, "Merge hint contains %d flows - two are expected\n",
0227                      flow_cnt);
0228         return;
0229     }
0230 
0231     rtnl_lock();
0232     for (i = 0; i < flow_cnt; i++) {
0233         u32 ctx = be32_to_cpu(msg->flow[i].host_ctx);
0234 
0235         sub_flows[i] = nfp_flower_get_fl_payload_from_ctx(app, ctx);
0236         if (!sub_flows[i]) {
0237             nfp_flower_cmsg_warn(app, "Invalid flow in merge hint\n");
0238             goto err_rtnl_unlock;
0239         }
0240     }
0241 
0242     err = nfp_flower_merge_offloaded_flows(app, sub_flows[0], sub_flows[1]);
0243     /* Only warn on memory fail. Hint veto will not break functionality. */
0244     if (err == -ENOMEM)
0245         nfp_flower_cmsg_warn(app, "Flow merge memory fail.\n");
0246 
0247 err_rtnl_unlock:
0248     rtnl_unlock();
0249 }
0250 
0251 static void
0252 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
0253 {
0254     struct nfp_flower_priv *app_priv = app->priv;
0255     struct nfp_flower_cmsg_hdr *cmsg_hdr;
0256     enum nfp_flower_cmsg_type_port type;
0257     bool skb_stored = false;
0258 
0259     cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
0260 
0261     type = cmsg_hdr->type;
0262     switch (type) {
0263     case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
0264         nfp_flower_cmsg_portmod_rx(app, skb);
0265         break;
0266     case NFP_FLOWER_CMSG_TYPE_MERGE_HINT:
0267         if (app_priv->flower_en_feats & NFP_FL_ENABLE_FLOW_MERGE) {
0268             nfp_flower_cmsg_merge_hint_rx(app, skb);
0269             break;
0270         }
0271         goto err_default;
0272     case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
0273         nfp_tunnel_request_route_v4(app, skb);
0274         break;
0275     case NFP_FLOWER_CMSG_TYPE_NO_NEIGH_V6:
0276         nfp_tunnel_request_route_v6(app, skb);
0277         break;
0278     case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
0279         nfp_tunnel_keep_alive(app, skb);
0280         break;
0281     case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS_V6:
0282         nfp_tunnel_keep_alive_v6(app, skb);
0283         break;
0284     case NFP_FLOWER_CMSG_TYPE_QOS_STATS:
0285         nfp_flower_stats_rlim_reply(app, skb);
0286         break;
0287     case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
0288         if (app_priv->flower_en_feats & NFP_FL_ENABLE_LAG) {
0289             skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
0290             break;
0291         }
0292         fallthrough;
0293     default:
0294 err_default:
0295         nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
0296                      type);
0297         goto out;
0298     }
0299 
0300     if (!skb_stored)
0301         dev_consume_skb_any(skb);
0302     return;
0303 out:
0304     dev_kfree_skb_any(skb);
0305 }
0306 
0307 void nfp_flower_cmsg_process_rx(struct work_struct *work)
0308 {
0309     struct sk_buff_head cmsg_joined;
0310     struct nfp_flower_priv *priv;
0311     struct sk_buff *skb;
0312 
0313     priv = container_of(work, struct nfp_flower_priv, cmsg_work);
0314     skb_queue_head_init(&cmsg_joined);
0315 
0316     spin_lock_bh(&priv->cmsg_skbs_high.lock);
0317     skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
0318     spin_unlock_bh(&priv->cmsg_skbs_high.lock);
0319 
0320     spin_lock_bh(&priv->cmsg_skbs_low.lock);
0321     skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
0322     spin_unlock_bh(&priv->cmsg_skbs_low.lock);
0323 
0324     while ((skb = __skb_dequeue(&cmsg_joined)))
0325         nfp_flower_cmsg_process_one_rx(priv->app, skb);
0326 }
0327 
0328 static void
0329 nfp_flower_queue_ctl_msg(struct nfp_app *app, struct sk_buff *skb, int type)
0330 {
0331     struct nfp_flower_priv *priv = app->priv;
0332     struct sk_buff_head *skb_head;
0333 
0334     if (type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
0335         skb_head = &priv->cmsg_skbs_high;
0336     else
0337         skb_head = &priv->cmsg_skbs_low;
0338 
0339     if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
0340         nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
0341         dev_kfree_skb_any(skb);
0342         return;
0343     }
0344 
0345     skb_queue_tail(skb_head, skb);
0346     schedule_work(&priv->cmsg_work);
0347 }
0348 
0349 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
0350 {
0351     struct nfp_flower_cmsg_hdr *cmsg_hdr;
0352 
0353     cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
0354 
0355     if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
0356         nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
0357                      cmsg_hdr->version);
0358         dev_kfree_skb_any(skb);
0359         return;
0360     }
0361 
0362     if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
0363         /* We need to deal with stats updates from HW asap */
0364         nfp_flower_rx_flow_stats(app, skb);
0365         dev_consume_skb_any(skb);
0366     } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
0367            nfp_flower_process_mtu_ack(app, skb)) {
0368         /* Handle MTU acks outside wq to prevent RTNL conflict. */
0369         dev_consume_skb_any(skb);
0370     } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH ||
0371            cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6) {
0372         /* Acks from the NFP that the route is added - ignore. */
0373         dev_consume_skb_any(skb);
0374     } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY) {
0375         /* Handle REIFY acks outside wq to prevent RTNL conflict. */
0376         nfp_flower_cmsg_portreify_rx(app, skb);
0377         dev_consume_skb_any(skb);
0378     } else {
0379         nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
0380     }
0381 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!