drivers/net/ethernet/netronome/nfp/flower/cmsg.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (C) 2015-2018 Netronome Systems, Inc. */
   3
   4 #include <linux/bitfield.h>
   5 #include <linux/netdevice.h>
   6 #include <linux/skbuff.h>
   7 #include <linux/workqueue.h>
   8 #include <net/dst_metadata.h>
   9
  10 #include "main.h"
  11 #include "../nfp_net.h"
  12 #include "../nfp_net_repr.h"
  13 #include "./cmsg.h"
  14
  15 static struct nfp_flower_cmsg_hdr *
  16 nfp_flower_cmsg_get_hdr(struct sk_buff *skb)
  17 {
  18         return (struct nfp_flower_cmsg_hdr *)skb->data;
  19 }
  20
  21 struct sk_buff *
  22 nfp_flower_cmsg_alloc(struct nfp_app *app, unsigned int size,
  23                       enum nfp_flower_cmsg_type_port type, gfp_t flag)
  24 {
  25         struct nfp_flower_cmsg_hdr *ch;
  26         struct sk_buff *skb;
  27
  28         size += NFP_FLOWER_CMSG_HLEN;
  29
  30         skb = nfp_app_ctrl_msg_alloc(app, size, flag);
  31         if (!skb)
  32                 return NULL;
  33
  34         ch = nfp_flower_cmsg_get_hdr(skb);
  35         ch->pad = 0;
  36         ch->version = NFP_FLOWER_CMSG_VER1;
  37         ch->type = type;
  38         skb_put(skb, size);
  39
  40         return skb;
  41 }
  42
  43 struct sk_buff *
  44 nfp_flower_cmsg_mac_repr_start(struct nfp_app *app, unsigned int num_ports)
  45 {
  46         struct nfp_flower_cmsg_mac_repr *msg;
  47         struct sk_buff *skb;
  48
  49         skb = nfp_flower_cmsg_alloc(app, struct_size(msg, ports, num_ports),
  50                                     NFP_FLOWER_CMSG_TYPE_MAC_REPR, GFP_KERNEL);
  51         if (!skb)
  52                 return NULL;
  53
  54         msg = nfp_flower_cmsg_get_data(skb);
  55         memset(msg->reserved, 0, sizeof(msg->reserved));
  56         msg->num_ports = num_ports;
  57
  58         return skb;
  59 }
  60
  61 void
  62 nfp_flower_cmsg_mac_repr_add(struct sk_buff *skb, unsigned int idx,
  63                              unsigned int nbi, unsigned int nbi_port,
  64                              unsigned int phys_port)
  65 {
  66         struct nfp_flower_cmsg_mac_repr *msg;
  67
  68         msg = nfp_flower_cmsg_get_data(skb);
  69         msg->ports[idx].idx = idx;
  70         msg->ports[idx].info = nbi & NFP_FLOWER_CMSG_MAC_REPR_NBI;
  71         msg->ports[idx].nbi_port = nbi_port;
  72         msg->ports[idx].phys_port = phys_port;
  73 }
  74
  75 int nfp_flower_cmsg_portmod(struct nfp_repr *repr, bool carrier_ok,
  76                             unsigned int mtu, bool mtu_only)
  77 {
  78         struct nfp_flower_cmsg_portmod *msg;
  79         struct sk_buff *skb;
  80
  81         skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
  82                                     NFP_FLOWER_CMSG_TYPE_PORT_MOD, GFP_KERNEL);
  83         if (!skb)
  84                 return -ENOMEM;
  85
  86         msg = nfp_flower_cmsg_get_data(skb);
  87         msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
  88         msg->reserved = 0;
  89         msg->info = carrier_ok;
  90
  91         if (mtu_only)
  92                 msg->info |= NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY;
  93
  94         msg->mtu = cpu_to_be16(mtu);
  95
  96         nfp_ctrl_tx(repr->app->ctrl, skb);
  97
  98         return 0;
  99 }
 100
 101 int nfp_flower_cmsg_portreify(struct nfp_repr *repr, bool exists)
 102 {
 103         struct nfp_flower_cmsg_portreify *msg;
 104         struct sk_buff *skb;
 105
 106         skb = nfp_flower_cmsg_alloc(repr->app, sizeof(*msg),
 107                                     NFP_FLOWER_CMSG_TYPE_PORT_REIFY,
 108                                     GFP_KERNEL);
 109         if (!skb)
 110                 return -ENOMEM;
 111
 112         msg = nfp_flower_cmsg_get_data(skb);
 113         msg->portnum = cpu_to_be32(repr->dst->u.port_info.port_id);
 114         msg->reserved = 0;
 115         msg->info = cpu_to_be16(exists);
 116
 117         nfp_ctrl_tx(repr->app->ctrl, skb);
 118
 119         return 0;
 120 }
 121
 122 static bool
 123 nfp_flower_process_mtu_ack(struct nfp_app *app, struct sk_buff *skb)
 124 {
 125         struct nfp_flower_priv *app_priv = app->priv;
 126         struct nfp_flower_cmsg_portmod *msg;
 127
 128         msg = nfp_flower_cmsg_get_data(skb);
 129
 130         if (!(msg->info & NFP_FLOWER_CMSG_PORTMOD_MTU_CHANGE_ONLY))
 131                 return false;
 132
 133         spin_lock_bh(&app_priv->mtu_conf.lock);
 134         if (!app_priv->mtu_conf.requested_val ||
 135             app_priv->mtu_conf.portnum != be32_to_cpu(msg->portnum) ||
 136             be16_to_cpu(msg->mtu) != app_priv->mtu_conf.requested_val) {
 137                 /* Not an ack for requested MTU change. */
 138                 spin_unlock_bh(&app_priv->mtu_conf.lock);
 139                 return false;
 140         }
 141
 142         app_priv->mtu_conf.ack = true;
 143         app_priv->mtu_conf.requested_val = 0;
 144         wake_up(&app_priv->mtu_conf.wait_q);
 145         spin_unlock_bh(&app_priv->mtu_conf.lock);
 146
 147         return true;
 148 }
 149
 150 static void
 151 nfp_flower_cmsg_portmod_rx(struct nfp_app *app, struct sk_buff *skb)
 152 {
 153         struct nfp_flower_cmsg_portmod *msg;
 154         struct net_device *netdev;
 155         bool link;
 156
 157         msg = nfp_flower_cmsg_get_data(skb);
 158         link = msg->info & NFP_FLOWER_CMSG_PORTMOD_INFO_LINK;
 159
 160         rtnl_lock();
 161         rcu_read_lock();
 162         netdev = nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
 163         rcu_read_unlock();
 164         if (!netdev) {
 165                 nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
 166                                      be32_to_cpu(msg->portnum));
 167                 rtnl_unlock();
 168                 return;
 169         }
 170
 171         if (link) {
 172                 u16 mtu = be16_to_cpu(msg->mtu);
 173
 174                 netif_carrier_on(netdev);
 175
 176                 /* An MTU of 0 from the firmware should be ignored */
 177                 if (mtu)
 178                         dev_set_mtu(netdev, mtu);
 179         } else {
 180                 netif_carrier_off(netdev);
 181         }
 182         rtnl_unlock();
 183 }
 184
 185 static void
 186 nfp_flower_cmsg_portreify_rx(struct nfp_app *app, struct sk_buff *skb)
 187 {
 188         struct nfp_flower_priv *priv = app->priv;
 189         struct nfp_flower_cmsg_portreify *msg;
 190         bool exists;
 191
 192         msg = nfp_flower_cmsg_get_data(skb);
 193
 194         rcu_read_lock();
 195         exists = !!nfp_app_dev_get(app, be32_to_cpu(msg->portnum), NULL);
 196         rcu_read_unlock();
 197         if (!exists) {
 198                 nfp_flower_cmsg_warn(app, "ctrl msg for unknown port 0x%08x\n",
 199                                      be32_to_cpu(msg->portnum));
 200                 return;
 201         }
 202
 203         atomic_inc(&priv->reify_replies);
 204         wake_up(&priv->reify_wait_queue);
 205 }
 206
 207 static void
 208 nfp_flower_cmsg_merge_hint_rx(struct nfp_app *app, struct sk_buff *skb)
 209 {
 210         unsigned int msg_len = nfp_flower_cmsg_get_data_len(skb);
 211         struct nfp_flower_cmsg_merge_hint *msg;
 212         struct nfp_fl_payload *sub_flows[2];
 213         struct nfp_flower_priv *priv;
 214         int err, i, flow_cnt;
 215
 216         msg = nfp_flower_cmsg_get_data(skb);
 217         /* msg->count starts at 0 and always assumes at least 1 entry. */
 218         flow_cnt = msg->count + 1;
 219
 220         if (msg_len < struct_size(msg, flow, flow_cnt)) {
 221                 nfp_flower_cmsg_warn(app, "Merge hint ctrl msg too short - %d bytes but expect %zd\n",
 222                                      msg_len, struct_size(msg, flow, flow_cnt));
 223                 return;
 224         }
 225
 226         if (flow_cnt != 2) {
 227                 nfp_flower_cmsg_warn(app, "Merge hint contains %d flows - two are expected\n",
 228                                      flow_cnt);
 229                 return;
 230         }
 231
 232         priv = app->priv;
 233         mutex_lock(&priv->nfp_fl_lock);
 234         for (i = 0; i < flow_cnt; i++) {
 235                 u32 ctx = be32_to_cpu(msg->flow[i].host_ctx);
 236
 237                 sub_flows[i] = nfp_flower_get_fl_payload_from_ctx(app, ctx);
 238                 if (!sub_flows[i]) {
 239                         nfp_flower_cmsg_warn(app, "Invalid flow in merge hint\n");
 240                         goto err_mutex_unlock;
 241                 }
 242         }
 243
 244         err = nfp_flower_merge_offloaded_flows(app, sub_flows[0], sub_flows[1]);
 245         /* Only warn on memory fail. Hint veto will not break functionality. */
 246         if (err == -ENOMEM)
 247                 nfp_flower_cmsg_warn(app, "Flow merge memory fail.\n");
 248
 249 err_mutex_unlock:
 250         mutex_unlock(&priv->nfp_fl_lock);
 251 }
 252
 253 static void
 254 nfp_flower_cmsg_process_one_rx(struct nfp_app *app, struct sk_buff *skb)
 255 {
 256         struct nfp_flower_priv *app_priv = app->priv;
 257         struct nfp_flower_cmsg_hdr *cmsg_hdr;
 258         enum nfp_flower_cmsg_type_port type;
 259         bool skb_stored = false;
 260
 261         cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
 262
 263         type = cmsg_hdr->type;
 264         switch (type) {
 265         case NFP_FLOWER_CMSG_TYPE_PORT_MOD:
 266                 nfp_flower_cmsg_portmod_rx(app, skb);
 267                 break;
 268         case NFP_FLOWER_CMSG_TYPE_MERGE_HINT:
 269                 if (app_priv->flower_en_feats & NFP_FL_ENABLE_FLOW_MERGE) {
 270                         nfp_flower_cmsg_merge_hint_rx(app, skb);
 271                         break;
 272                 }
 273                 goto err_default;
 274         case NFP_FLOWER_CMSG_TYPE_NO_NEIGH:
 275                 nfp_tunnel_request_route_v4(app, skb);
 276                 break;
 277         case NFP_FLOWER_CMSG_TYPE_NO_NEIGH_V6:
 278                 nfp_tunnel_request_route_v6(app, skb);
 279                 break;
 280         case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS:
 281                 nfp_tunnel_keep_alive(app, skb);
 282                 break;
 283         case NFP_FLOWER_CMSG_TYPE_ACTIVE_TUNS_V6:
 284                 nfp_tunnel_keep_alive_v6(app, skb);
 285                 break;
 286         case NFP_FLOWER_CMSG_TYPE_QOS_STATS:
 287                 nfp_flower_stats_rlim_reply(app, skb);
 288                 break;
 289         case NFP_FLOWER_CMSG_TYPE_LAG_CONFIG:
 290                 if (app_priv->flower_en_feats & NFP_FL_ENABLE_LAG) {
 291                         skb_stored = nfp_flower_lag_unprocessed_msg(app, skb);
 292                         break;
 293                 }
 294                 fallthrough;
 295         default:
 296 err_default:
 297                 nfp_flower_cmsg_warn(app, "Cannot handle invalid repr control type %u\n",
 298                                      type);
 299                 goto out;
 300         }
 301
 302         if (!skb_stored)
 303                 dev_consume_skb_any(skb);
 304         return;
 305 out:
 306         dev_kfree_skb_any(skb);
 307 }
 308
 309 void nfp_flower_cmsg_process_rx(struct work_struct *work)
 310 {
 311         struct sk_buff_head cmsg_joined;
 312         struct nfp_flower_priv *priv;
 313         struct sk_buff *skb;
 314
 315         priv = container_of(work, struct nfp_flower_priv, cmsg_work);
 316         skb_queue_head_init(&cmsg_joined);
 317
 318         spin_lock_bh(&priv->cmsg_skbs_high.lock);
 319         skb_queue_splice_tail_init(&priv->cmsg_skbs_high, &cmsg_joined);
 320         spin_unlock_bh(&priv->cmsg_skbs_high.lock);
 321
 322         spin_lock_bh(&priv->cmsg_skbs_low.lock);
 323         skb_queue_splice_tail_init(&priv->cmsg_skbs_low, &cmsg_joined);
 324         spin_unlock_bh(&priv->cmsg_skbs_low.lock);
 325
 326         while ((skb = __skb_dequeue(&cmsg_joined)))
 327                 nfp_flower_cmsg_process_one_rx(priv->app, skb);
 328 }
 329
 330 static void
 331 nfp_flower_queue_ctl_msg(struct nfp_app *app, struct sk_buff *skb, int type)
 332 {
 333         struct nfp_flower_priv *priv = app->priv;
 334         struct sk_buff_head *skb_head;
 335
 336         if (type == NFP_FLOWER_CMSG_TYPE_PORT_MOD)
 337                 skb_head = &priv->cmsg_skbs_high;
 338         else
 339                 skb_head = &priv->cmsg_skbs_low;
 340
 341         if (skb_queue_len(skb_head) >= NFP_FLOWER_WORKQ_MAX_SKBS) {
 342                 nfp_flower_cmsg_warn(app, "Dropping queued control messages\n");
 343                 dev_kfree_skb_any(skb);
 344                 return;
 345         }
 346
 347         skb_queue_tail(skb_head, skb);
 348         schedule_work(&priv->cmsg_work);
 349 }
 350
 351 void nfp_flower_cmsg_rx(struct nfp_app *app, struct sk_buff *skb)
 352 {
 353         struct nfp_flower_cmsg_hdr *cmsg_hdr;
 354
 355         cmsg_hdr = nfp_flower_cmsg_get_hdr(skb);
 356
 357         if (unlikely(cmsg_hdr->version != NFP_FLOWER_CMSG_VER1)) {
 358                 nfp_flower_cmsg_warn(app, "Cannot handle repr control version %u\n",
 359                                      cmsg_hdr->version);
 360                 dev_kfree_skb_any(skb);
 361                 return;
 362         }
 363
 364         if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_FLOW_STATS) {
 365                 /* We need to deal with stats updates from HW asap */
 366                 nfp_flower_rx_flow_stats(app, skb);
 367                 dev_consume_skb_any(skb);
 368         } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_MOD &&
 369                    nfp_flower_process_mtu_ack(app, skb)) {
 370                 /* Handle MTU acks outside wq to prevent RTNL conflict. */
 371                 dev_consume_skb_any(skb);
 372         } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH ||
 373                    cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6) {
 374                 /* Acks from the NFP that the route is added - ignore. */
 375                 dev_consume_skb_any(skb);
 376         } else if (cmsg_hdr->type == NFP_FLOWER_CMSG_TYPE_PORT_REIFY) {
 377                 /* Handle REIFY acks outside wq to prevent RTNL conflict. */
 378                 nfp_flower_cmsg_portreify_rx(app, skb);
 379                 dev_consume_skb_any(skb);
 380         } else {
 381                 nfp_flower_queue_ctl_msg(app, skb, cmsg_hdr->type);
 382         }
 383 }