drivers/net/ethernet/mellanox/mlx5/core/en_arfs.c

   1 /*
   2  * Copyright (c) 2016, Mellanox Technologies. All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *        copyright notice, this list of conditions and the following
  20  *        disclaimer in the documentation and/or other materials
  21  *        provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/hash.h>
  34 #include <linux/mlx5/fs.h>
  35 #include <linux/ip.h>
  36 #include <linux/ipv6.h>
  37 #include <net/rps.h>
  38 #include "en.h"
  39
  40 #define ARFS_HASH_SHIFT BITS_PER_BYTE
  41 #define ARFS_HASH_SIZE BIT(BITS_PER_BYTE)
  42
  43 struct arfs_table {
  44         struct mlx5e_flow_table  ft;
  45         struct mlx5_flow_handle  *default_rule;
  46         struct hlist_head        rules_hash[ARFS_HASH_SIZE];
  47 };
  48
  49 enum arfs_type {
  50         ARFS_IPV4_TCP,
  51         ARFS_IPV6_TCP,
  52         ARFS_IPV4_UDP,
  53         ARFS_IPV6_UDP,
  54         ARFS_NUM_TYPES,
  55 };
  56
  57 struct mlx5e_arfs_tables {
  58         struct arfs_table arfs_tables[ARFS_NUM_TYPES];
  59         /* Protect aRFS rules list */
  60         spinlock_t                     arfs_lock;
  61         int                            last_filter_id;
  62         struct workqueue_struct        *wq;
  63 };
  64
  65 struct arfs_tuple {
  66         __be16 etype;
  67         u8     ip_proto;
  68         union {
  69                 __be32 src_ipv4;
  70                 struct in6_addr src_ipv6;
  71         };
  72         union {
  73                 __be32 dst_ipv4;
  74                 struct in6_addr dst_ipv6;
  75         };
  76         __be16 src_port;
  77         __be16 dst_port;
  78 };
  79
  80 struct arfs_rule {
  81         struct mlx5e_priv       *priv;
  82         struct work_struct      arfs_work;
  83         struct mlx5_flow_handle *rule;
  84         struct hlist_node       hlist;
  85         int                     rxq;
  86         /* Flow ID passed to ndo_rx_flow_steer */
  87         int                     flow_id;
  88         /* Filter ID returned by ndo_rx_flow_steer */
  89         int                     filter_id;
  90         struct arfs_tuple       tuple;
  91 };
  92
  93 #define mlx5e_for_each_arfs_rule(hn, tmp, arfs_tables, i, j) \
  94         for (i = 0; i < ARFS_NUM_TYPES; i++) \
  95                 mlx5e_for_each_hash_arfs_rule(hn, tmp, arfs_tables[i].rules_hash, j)
  96
  97 #define mlx5e_for_each_hash_arfs_rule(hn, tmp, hash, j) \
  98         for (j = 0; j < ARFS_HASH_SIZE; j++) \
  99                 hlist_for_each_entry_safe(hn, tmp, &hash[j], hlist)
 100
 101 static enum mlx5_traffic_types arfs_get_tt(enum arfs_type type)
 102 {
 103         switch (type) {
 104         case ARFS_IPV4_TCP:
 105                 return MLX5_TT_IPV4_TCP;
 106         case ARFS_IPV4_UDP:
 107                 return MLX5_TT_IPV4_UDP;
 108         case ARFS_IPV6_TCP:
 109                 return MLX5_TT_IPV6_TCP;
 110         case ARFS_IPV6_UDP:
 111                 return MLX5_TT_IPV6_UDP;
 112         default:
 113                 return -EINVAL;
 114         }
 115 }
 116
 117 static int arfs_disable(struct mlx5e_flow_steering *fs)
 118 {
 119         struct mlx5_ttc_table *ttc = mlx5e_fs_get_ttc(fs, false);
 120         int err, i;
 121
 122         for (i = 0; i < ARFS_NUM_TYPES; i++) {
 123                 /* Modify ttc rules destination back to their default */
 124                 err = mlx5_ttc_fwd_default_dest(ttc, arfs_get_tt(i));
 125                 if (err) {
 126                         fs_err(fs,
 127                                "%s: modify ttc[%d] default destination failed, err(%d)\n",
 128                                __func__, arfs_get_tt(i), err);
 129                         return err;
 130                 }
 131         }
 132         return 0;
 133 }
 134
 135 static void arfs_del_rules(struct mlx5e_flow_steering *fs);
 136
 137 int mlx5e_arfs_disable(struct mlx5e_flow_steering *fs)
 138 {
 139         /* Moving to switchdev mode, fs->arfs is freed by mlx5e_nic_profile
 140          * cleanup_rx callback and it is not recreated when
 141          * mlx5e_uplink_rep_profile is loaded as mlx5e_create_flow_steering()
 142          * is not called by the uplink_rep profile init_rx callback. Thus, if
 143          * ntuple is set, moving to switchdev flow will enter this function
 144          * with fs->arfs nullified.
 145          */
 146         if (!mlx5e_fs_get_arfs(fs))
 147                 return 0;
 148
 149         arfs_del_rules(fs);
 150
 151         return arfs_disable(fs);
 152 }
 153
 154 int mlx5e_arfs_enable(struct mlx5e_flow_steering *fs)
 155 {
 156         struct mlx5_ttc_table *ttc = mlx5e_fs_get_ttc(fs, false);
 157         struct mlx5e_arfs_tables *arfs =  mlx5e_fs_get_arfs(fs);
 158         struct mlx5_flow_destination dest = {};
 159         int err, i;
 160
 161         dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
 162         for (i = 0; i < ARFS_NUM_TYPES; i++) {
 163                 dest.ft = arfs->arfs_tables[i].ft.t;
 164                 /* Modify ttc rules destination to point on the aRFS FTs */
 165                 err = mlx5_ttc_fwd_dest(ttc, arfs_get_tt(i), &dest);
 166                 if (err) {
 167                         fs_err(fs, "%s: modify ttc[%d] dest to arfs, failed err(%d)\n",
 168                                __func__, arfs_get_tt(i), err);
 169                         arfs_disable(fs);
 170                         return err;
 171                 }
 172         }
 173         return 0;
 174 }
 175
 176 static void arfs_destroy_table(struct arfs_table *arfs_t)
 177 {
 178         mlx5_del_flow_rules(arfs_t->default_rule);
 179         mlx5e_destroy_flow_table(&arfs_t->ft);
 180 }
 181
 182 static void _mlx5e_cleanup_tables(struct mlx5e_flow_steering *fs)
 183 {
 184         struct mlx5e_arfs_tables *arfs =  mlx5e_fs_get_arfs(fs);
 185         int i;
 186
 187         arfs_del_rules(fs);
 188         destroy_workqueue(arfs->wq);
 189         for (i = 0; i < ARFS_NUM_TYPES; i++) {
 190                 if (!IS_ERR_OR_NULL(arfs->arfs_tables[i].ft.t))
 191                         arfs_destroy_table(&arfs->arfs_tables[i]);
 192         }
 193 }
 194
 195 void mlx5e_arfs_destroy_tables(struct mlx5e_flow_steering *fs, bool ntuple)
 196 {
 197         struct mlx5e_arfs_tables *arfs =  mlx5e_fs_get_arfs(fs);
 198
 199         if (!ntuple)
 200                 return;
 201
 202         _mlx5e_cleanup_tables(fs);
 203         mlx5e_fs_set_arfs(fs, NULL);
 204         kvfree(arfs);
 205 }
 206
 207 static int arfs_add_default_rule(struct mlx5e_flow_steering *fs,
 208                                  struct mlx5e_rx_res *rx_res,
 209                                  enum arfs_type type)
 210 {
 211         struct mlx5e_arfs_tables *arfs =  mlx5e_fs_get_arfs(fs);
 212         struct arfs_table *arfs_t = &arfs->arfs_tables[type];
 213         struct mlx5_flow_destination dest = {};
 214         MLX5_DECLARE_FLOW_ACT(flow_act);
 215         enum mlx5_traffic_types tt;
 216         int err = 0;
 217
 218         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 219         tt = arfs_get_tt(type);
 220         if (tt == -EINVAL) {
 221                 fs_err(fs, "%s: bad arfs_type: %d\n", __func__, type);
 222                 return -EINVAL;
 223         }
 224
 225         /* FIXME: Must use mlx5_ttc_get_default_dest(),
 226          * but can't since TTC default is not setup yet !
 227          */
 228         dest.tir_num = mlx5e_rx_res_get_tirn_rss(rx_res, tt);
 229         arfs_t->default_rule = mlx5_add_flow_rules(arfs_t->ft.t, NULL,
 230                                                    &flow_act,
 231                                                    &dest, 1);
 232         if (IS_ERR(arfs_t->default_rule)) {
 233                 err = PTR_ERR(arfs_t->default_rule);
 234                 arfs_t->default_rule = NULL;
 235                 fs_err(fs, "%s: add rule failed, arfs type=%d\n", __func__, type);
 236         }
 237
 238         return err;
 239 }
 240
 241 #define MLX5E_ARFS_NUM_GROUPS   2
 242 #define MLX5E_ARFS_GROUP1_SIZE  (BIT(16) - 1)
 243 #define MLX5E_ARFS_GROUP2_SIZE  BIT(0)
 244 #define MLX5E_ARFS_TABLE_SIZE   (MLX5E_ARFS_GROUP1_SIZE +\
 245                                  MLX5E_ARFS_GROUP2_SIZE)
 246 static int arfs_create_groups(struct mlx5e_flow_table *ft,
 247                               enum  arfs_type type)
 248 {
 249         int inlen = MLX5_ST_SZ_BYTES(create_flow_group_in);
 250         void *outer_headers_c;
 251         int ix = 0;
 252         u32 *in;
 253         int err;
 254         u8 *mc;
 255
 256         ft->g = kcalloc(MLX5E_ARFS_NUM_GROUPS,
 257                         sizeof(*ft->g), GFP_KERNEL);
 258         if (!ft->g)
 259                 return -ENOMEM;
 260
 261         in = kvzalloc(inlen, GFP_KERNEL);
 262         if (!in) {
 263                 err = -ENOMEM;
 264                 goto err_free_g;
 265         }
 266
 267         mc = MLX5_ADDR_OF(create_flow_group_in, in, match_criteria);
 268         outer_headers_c = MLX5_ADDR_OF(fte_match_param, mc,
 269                                        outer_headers);
 270         MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, ethertype);
 271         switch (type) {
 272         case ARFS_IPV4_TCP:
 273         case ARFS_IPV6_TCP:
 274                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, tcp_dport);
 275                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, tcp_sport);
 276                 break;
 277         case ARFS_IPV4_UDP:
 278         case ARFS_IPV6_UDP:
 279                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, udp_dport);
 280                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c, udp_sport);
 281                 break;
 282         default:
 283                 err = -EINVAL;
 284                 goto err_free_in;
 285         }
 286
 287         switch (type) {
 288         case ARFS_IPV4_TCP:
 289         case ARFS_IPV4_UDP:
 290                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c,
 291                                  src_ipv4_src_ipv6.ipv4_layout.ipv4);
 292                 MLX5_SET_TO_ONES(fte_match_set_lyr_2_4, outer_headers_c,
 293                                  dst_ipv4_dst_ipv6.ipv4_layout.ipv4);
 294                 break;
 295         case ARFS_IPV6_TCP:
 296         case ARFS_IPV6_UDP:
 297                 memset(MLX5_ADDR_OF(fte_match_set_lyr_2_4, outer_headers_c,
 298                                     src_ipv4_src_ipv6.ipv6_layout.ipv6),
 299                        0xff, 16);
 300                 memset(MLX5_ADDR_OF(fte_match_set_lyr_2_4, outer_headers_c,
 301                                     dst_ipv4_dst_ipv6.ipv6_layout.ipv6),
 302                        0xff, 16);
 303                 break;
 304         default:
 305                 err = -EINVAL;
 306                 goto err_free_in;
 307         }
 308
 309         MLX5_SET_CFG(in, match_criteria_enable, MLX5_MATCH_OUTER_HEADERS);
 310         MLX5_SET_CFG(in, start_flow_index, ix);
 311         ix += MLX5E_ARFS_GROUP1_SIZE;
 312         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 313         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 314         if (IS_ERR(ft->g[ft->num_groups]))
 315                 goto err_clean_group;
 316         ft->num_groups++;
 317
 318         memset(in, 0, inlen);
 319         MLX5_SET_CFG(in, start_flow_index, ix);
 320         ix += MLX5E_ARFS_GROUP2_SIZE;
 321         MLX5_SET_CFG(in, end_flow_index, ix - 1);
 322         ft->g[ft->num_groups] = mlx5_create_flow_group(ft->t, in);
 323         if (IS_ERR(ft->g[ft->num_groups]))
 324                 goto err_clean_group;
 325         ft->num_groups++;
 326
 327         kvfree(in);
 328         return 0;
 329
 330 err_clean_group:
 331         err = PTR_ERR(ft->g[ft->num_groups]);
 332         ft->g[ft->num_groups] = NULL;
 333 err_free_in:
 334         kvfree(in);
 335 err_free_g:
 336         kfree(ft->g);
 337         ft->g = NULL;
 338         return err;
 339 }
 340
 341 static int arfs_create_table(struct mlx5e_flow_steering *fs,
 342                              struct mlx5e_rx_res *rx_res,
 343                              enum arfs_type type)
 344 {
 345         struct mlx5_flow_namespace *ns = mlx5e_fs_get_ns(fs, false);
 346         struct mlx5e_arfs_tables *arfs = mlx5e_fs_get_arfs(fs);
 347         struct mlx5e_flow_table *ft = &arfs->arfs_tables[type].ft;
 348         struct mlx5_flow_table_attr ft_attr = {};
 349         int err;
 350
 351         ft->num_groups = 0;
 352
 353         ft_attr.max_fte = MLX5E_ARFS_TABLE_SIZE;
 354         ft_attr.level = MLX5E_ARFS_FT_LEVEL;
 355         ft_attr.prio = MLX5E_NIC_PRIO;
 356
 357         ft->t = mlx5_create_flow_table(ns, &ft_attr);
 358         if (IS_ERR(ft->t)) {
 359                 err = PTR_ERR(ft->t);
 360                 ft->t = NULL;
 361                 return err;
 362         }
 363
 364         err = arfs_create_groups(ft, type);
 365         if (err)
 366                 goto err;
 367
 368         err = arfs_add_default_rule(fs, rx_res,  type);
 369         if (err)
 370                 goto err;
 371
 372         return 0;
 373 err:
 374         mlx5e_destroy_flow_table(ft);
 375         return err;
 376 }
 377
 378 int mlx5e_arfs_create_tables(struct mlx5e_flow_steering *fs,
 379                              struct mlx5e_rx_res *rx_res, bool ntuple)
 380 {
 381         struct mlx5e_arfs_tables *arfs;
 382         int err = -ENOMEM;
 383         int i;
 384
 385         if (!ntuple)
 386                 return 0;
 387
 388         arfs = kvzalloc(sizeof(*arfs), GFP_KERNEL);
 389         if (!arfs)
 390                 return -ENOMEM;
 391
 392         spin_lock_init(&arfs->arfs_lock);
 393         arfs->wq = create_singlethread_workqueue("mlx5e_arfs");
 394         if (!arfs->wq)
 395                 goto err;
 396
 397         mlx5e_fs_set_arfs(fs, arfs);
 398
 399         for (i = 0; i < ARFS_NUM_TYPES; i++) {
 400                 err = arfs_create_table(fs, rx_res, i);
 401                 if (err)
 402                         goto err_des;
 403         }
 404         return 0;
 405
 406 err_des:
 407         _mlx5e_cleanup_tables(fs);
 408 err:
 409         mlx5e_fs_set_arfs(fs, NULL);
 410         kvfree(arfs);
 411         return err;
 412 }
 413
 414 #define MLX5E_ARFS_EXPIRY_QUOTA 60
 415
 416 static void arfs_may_expire_flow(struct mlx5e_priv *priv)
 417 {
 418         struct mlx5e_arfs_tables *arfs = mlx5e_fs_get_arfs(priv->fs);
 419         struct arfs_rule *arfs_rule;
 420         struct hlist_node *htmp;
 421         HLIST_HEAD(del_list);
 422         int quota = 0;
 423         int i;
 424         int j;
 425
 426         spin_lock_bh(&arfs->arfs_lock);
 427         mlx5e_for_each_arfs_rule(arfs_rule, htmp, arfs->arfs_tables, i, j) {
 428                 if (!work_pending(&arfs_rule->arfs_work) &&
 429                     rps_may_expire_flow(priv->netdev,
 430                                         arfs_rule->rxq, arfs_rule->flow_id,
 431                                         arfs_rule->filter_id)) {
 432                         hlist_del_init(&arfs_rule->hlist);
 433                         hlist_add_head(&arfs_rule->hlist, &del_list);
 434                         if (quota++ > MLX5E_ARFS_EXPIRY_QUOTA)
 435                                 break;
 436                 }
 437         }
 438         spin_unlock_bh(&arfs->arfs_lock);
 439         hlist_for_each_entry_safe(arfs_rule, htmp, &del_list, hlist) {
 440                 if (arfs_rule->rule) {
 441                         mlx5_del_flow_rules(arfs_rule->rule);
 442                         priv->channel_stats[arfs_rule->rxq]->rq.arfs_expired++;
 443                 }
 444                 hlist_del(&arfs_rule->hlist);
 445                 kfree(arfs_rule);
 446         }
 447 }
 448
 449 static void arfs_del_rules(struct mlx5e_flow_steering *fs)
 450 {
 451         struct mlx5e_arfs_tables *arfs = mlx5e_fs_get_arfs(fs);
 452         struct hlist_node *htmp;
 453         struct arfs_rule *rule;
 454         HLIST_HEAD(del_list);
 455         int i;
 456         int j;
 457
 458         spin_lock_bh(&arfs->arfs_lock);
 459         mlx5e_for_each_arfs_rule(rule, htmp, arfs->arfs_tables, i, j) {
 460                 hlist_del_init(&rule->hlist);
 461                 hlist_add_head(&rule->hlist, &del_list);
 462         }
 463         spin_unlock_bh(&arfs->arfs_lock);
 464
 465         hlist_for_each_entry_safe(rule, htmp, &del_list, hlist) {
 466                 cancel_work_sync(&rule->arfs_work);
 467                 if (rule->rule)
 468                         mlx5_del_flow_rules(rule->rule);
 469                 hlist_del(&rule->hlist);
 470                 kfree(rule);
 471         }
 472 }
 473
 474 static struct hlist_head *
 475 arfs_hash_bucket(struct arfs_table *arfs_t, __be16 src_port,
 476                  __be16 dst_port)
 477 {
 478         unsigned long l;
 479         int bucket_idx;
 480
 481         l = (__force unsigned long)src_port |
 482             ((__force unsigned long)dst_port << 2);
 483
 484         bucket_idx = hash_long(l, ARFS_HASH_SHIFT);
 485
 486         return &arfs_t->rules_hash[bucket_idx];
 487 }
 488
 489 static struct arfs_table *arfs_get_table(struct mlx5e_arfs_tables *arfs,
 490                                          u8 ip_proto, __be16 etype)
 491 {
 492         if (etype == htons(ETH_P_IP) && ip_proto == IPPROTO_TCP)
 493                 return &arfs->arfs_tables[ARFS_IPV4_TCP];
 494         if (etype == htons(ETH_P_IP) && ip_proto == IPPROTO_UDP)
 495                 return &arfs->arfs_tables[ARFS_IPV4_UDP];
 496         if (etype == htons(ETH_P_IPV6) && ip_proto == IPPROTO_TCP)
 497                 return &arfs->arfs_tables[ARFS_IPV6_TCP];
 498         if (etype == htons(ETH_P_IPV6) && ip_proto == IPPROTO_UDP)
 499                 return &arfs->arfs_tables[ARFS_IPV6_UDP];
 500
 501         return NULL;
 502 }
 503
 504 static struct mlx5_flow_handle *arfs_add_rule(struct mlx5e_priv *priv,
 505                                               struct arfs_rule *arfs_rule)
 506 {
 507         struct mlx5e_arfs_tables *arfs = mlx5e_fs_get_arfs(priv->fs);
 508         struct arfs_tuple *tuple = &arfs_rule->tuple;
 509         struct mlx5_flow_handle *rule = NULL;
 510         struct mlx5_flow_destination dest = {};
 511         MLX5_DECLARE_FLOW_ACT(flow_act);
 512         struct arfs_table *arfs_table;
 513         struct mlx5_flow_spec *spec;
 514         struct mlx5_flow_table *ft;
 515         int err = 0;
 516
 517         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
 518         if (!spec) {
 519                 priv->channel_stats[arfs_rule->rxq]->rq.arfs_err++;
 520                 err = -ENOMEM;
 521                 goto out;
 522         }
 523         spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS;
 524         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 525                          outer_headers.ethertype);
 526         MLX5_SET(fte_match_param, spec->match_value, outer_headers.ethertype,
 527                  ntohs(tuple->etype));
 528         arfs_table = arfs_get_table(arfs, tuple->ip_proto, tuple->etype);
 529         if (!arfs_table) {
 530                 WARN_ONCE(1, "arfs table does not exist for etype %u and ip_proto %u\n",
 531                           tuple->etype, tuple->ip_proto);
 532                 err = -EINVAL;
 533                 goto out;
 534         }
 535
 536         ft = arfs_table->ft.t;
 537         if (tuple->ip_proto == IPPROTO_TCP) {
 538                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 539                                  outer_headers.tcp_dport);
 540                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 541                                  outer_headers.tcp_sport);
 542                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.tcp_dport,
 543                          ntohs(tuple->dst_port));
 544                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.tcp_sport,
 545                          ntohs(tuple->src_port));
 546         } else {
 547                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 548                                  outer_headers.udp_dport);
 549                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 550                                  outer_headers.udp_sport);
 551                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.udp_dport,
 552                          ntohs(tuple->dst_port));
 553                 MLX5_SET(fte_match_param, spec->match_value, outer_headers.udp_sport,
 554                          ntohs(tuple->src_port));
 555         }
 556         if (tuple->etype == htons(ETH_P_IP)) {
 557                 memcpy(MLX5_ADDR_OF(fte_match_param, spec->match_value,
 558                                     outer_headers.src_ipv4_src_ipv6.ipv4_layout.ipv4),
 559                        &tuple->src_ipv4,
 560                        4);
 561                 memcpy(MLX5_ADDR_OF(fte_match_param, spec->match_value,
 562                                     outer_headers.dst_ipv4_dst_ipv6.ipv4_layout.ipv4),
 563                        &tuple->dst_ipv4,
 564                        4);
 565                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 566                                  outer_headers.src_ipv4_src_ipv6.ipv4_layout.ipv4);
 567                 MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 568                                  outer_headers.dst_ipv4_dst_ipv6.ipv4_layout.ipv4);
 569         } else {
 570                 memcpy(MLX5_ADDR_OF(fte_match_param, spec->match_value,
 571                                     outer_headers.src_ipv4_src_ipv6.ipv6_layout.ipv6),
 572                        &tuple->src_ipv6,
 573                        16);
 574                 memcpy(MLX5_ADDR_OF(fte_match_param, spec->match_value,
 575                                     outer_headers.dst_ipv4_dst_ipv6.ipv6_layout.ipv6),
 576                        &tuple->dst_ipv6,
 577                        16);
 578                 memset(MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 579                                     outer_headers.src_ipv4_src_ipv6.ipv6_layout.ipv6),
 580                        0xff,
 581                        16);
 582                 memset(MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
 583                                     outer_headers.dst_ipv4_dst_ipv6.ipv6_layout.ipv6),
 584                        0xff,
 585                        16);
 586         }
 587         dest.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 588         dest.tir_num = mlx5e_rx_res_get_tirn_direct(priv->rx_res, arfs_rule->rxq);
 589         rule = mlx5_add_flow_rules(ft, spec, &flow_act, &dest, 1);
 590         if (IS_ERR(rule)) {
 591                 err = PTR_ERR(rule);
 592                 priv->channel_stats[arfs_rule->rxq]->rq.arfs_err++;
 593                 netdev_dbg(priv->netdev,
 594                            "%s: add rule(filter id=%d, rq idx=%d, ip proto=0x%x) failed,err=%d\n",
 595                            __func__, arfs_rule->filter_id, arfs_rule->rxq,
 596                            tuple->ip_proto, err);
 597         }
 598
 599 out:
 600         kvfree(spec);
 601         return err ? ERR_PTR(err) : rule;
 602 }
 603
 604 static void arfs_modify_rule_rq(struct mlx5e_priv *priv,
 605                                 struct mlx5_flow_handle *rule, u16 rxq)
 606 {
 607         struct mlx5_flow_destination dst = {};
 608         int err = 0;
 609
 610         dst.type = MLX5_FLOW_DESTINATION_TYPE_TIR;
 611         dst.tir_num = mlx5e_rx_res_get_tirn_direct(priv->rx_res, rxq);
 612         err =  mlx5_modify_rule_destination(rule, &dst, NULL);
 613         if (err) {
 614                 priv->channel_stats[rxq]->rq.arfs_err++;
 615                 netdev_warn(priv->netdev,
 616                             "Failed to modify aRFS rule destination to rq=%d\n", rxq);
 617         }
 618 }
 619
 620 static void arfs_handle_work(struct work_struct *work)
 621 {
 622         struct arfs_rule *arfs_rule = container_of(work,
 623                                                    struct arfs_rule,
 624                                                    arfs_work);
 625         struct mlx5e_priv *priv = arfs_rule->priv;
 626         struct mlx5e_arfs_tables *arfs;
 627         struct mlx5_flow_handle *rule;
 628
 629         arfs = mlx5e_fs_get_arfs(priv->fs);
 630         mutex_lock(&priv->state_lock);
 631         if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
 632                 spin_lock_bh(&arfs->arfs_lock);
 633                 hlist_del(&arfs_rule->hlist);
 634                 spin_unlock_bh(&arfs->arfs_lock);
 635
 636                 mutex_unlock(&priv->state_lock);
 637                 kfree(arfs_rule);
 638                 goto out;
 639         }
 640         mutex_unlock(&priv->state_lock);
 641
 642         if (!arfs_rule->rule) {
 643                 rule = arfs_add_rule(priv, arfs_rule);
 644                 if (IS_ERR(rule))
 645                         goto out;
 646                 arfs_rule->rule = rule;
 647                 priv->channel_stats[arfs_rule->rxq]->rq.arfs_add++;
 648         } else {
 649                 arfs_modify_rule_rq(priv, arfs_rule->rule,
 650                                     arfs_rule->rxq);
 651         }
 652 out:
 653         arfs_may_expire_flow(priv);
 654 }
 655
 656 static struct arfs_rule *arfs_alloc_rule(struct mlx5e_priv *priv,
 657                                          struct arfs_table *arfs_t,
 658                                          const struct flow_keys *fk,
 659                                          u16 rxq, u32 flow_id)
 660 {
 661         struct mlx5e_arfs_tables *arfs =  mlx5e_fs_get_arfs(priv->fs);
 662         struct arfs_rule *rule;
 663         struct arfs_tuple *tuple;
 664
 665         rule = kzalloc(sizeof(*rule), GFP_ATOMIC);
 666         if (!rule) {
 667                 priv->channel_stats[rxq]->rq.arfs_err++;
 668                 return NULL;
 669         }
 670
 671         rule->priv = priv;
 672         rule->rxq = rxq;
 673         INIT_WORK(&rule->arfs_work, arfs_handle_work);
 674
 675         tuple = &rule->tuple;
 676         tuple->etype = fk->basic.n_proto;
 677         tuple->ip_proto = fk->basic.ip_proto;
 678         if (tuple->etype == htons(ETH_P_IP)) {
 679                 tuple->src_ipv4 = fk->addrs.v4addrs.src;
 680                 tuple->dst_ipv4 = fk->addrs.v4addrs.dst;
 681         } else {
 682                 memcpy(&tuple->src_ipv6, &fk->addrs.v6addrs.src,
 683                        sizeof(struct in6_addr));
 684                 memcpy(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,
 685                        sizeof(struct in6_addr));
 686         }
 687         tuple->src_port = fk->ports.src;
 688         tuple->dst_port = fk->ports.dst;
 689
 690         rule->flow_id = flow_id;
 691         rule->filter_id = arfs->last_filter_id++ % RPS_NO_FILTER;
 692
 693         hlist_add_head(&rule->hlist,
 694                        arfs_hash_bucket(arfs_t, tuple->src_port,
 695                                         tuple->dst_port));
 696         return rule;
 697 }
 698
 699 static bool arfs_cmp(const struct arfs_tuple *tuple, const struct flow_keys *fk)
 700 {
 701         if (tuple->src_port != fk->ports.src || tuple->dst_port != fk->ports.dst)
 702                 return false;
 703         if (tuple->etype != fk->basic.n_proto)
 704                 return false;
 705         if (tuple->etype == htons(ETH_P_IP))
 706                 return tuple->src_ipv4 == fk->addrs.v4addrs.src &&
 707                        tuple->dst_ipv4 == fk->addrs.v4addrs.dst;
 708         if (tuple->etype == htons(ETH_P_IPV6))
 709                 return !memcmp(&tuple->src_ipv6, &fk->addrs.v6addrs.src,
 710                                sizeof(struct in6_addr)) &&
 711                        !memcmp(&tuple->dst_ipv6, &fk->addrs.v6addrs.dst,
 712                                sizeof(struct in6_addr));
 713         return false;
 714 }
 715
 716 static struct arfs_rule *arfs_find_rule(struct arfs_table *arfs_t,
 717                                         const struct flow_keys *fk)
 718 {
 719         struct arfs_rule *arfs_rule;
 720         struct hlist_head *head;
 721
 722         head = arfs_hash_bucket(arfs_t, fk->ports.src, fk->ports.dst);
 723         hlist_for_each_entry(arfs_rule, head, hlist) {
 724                 if (arfs_cmp(&arfs_rule->tuple, fk))
 725                         return arfs_rule;
 726         }
 727
 728         return NULL;
 729 }
 730
 731 int mlx5e_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb,
 732                         u16 rxq_index, u32 flow_id)
 733 {
 734         struct mlx5e_priv *priv = netdev_priv(dev);
 735         struct mlx5e_arfs_tables *arfs;
 736         struct arfs_rule *arfs_rule;
 737         struct arfs_table *arfs_t;
 738         struct flow_keys fk;
 739
 740         arfs =  mlx5e_fs_get_arfs(priv->fs);
 741         if (!skb_flow_dissect_flow_keys(skb, &fk, 0))
 742                 return -EPROTONOSUPPORT;
 743
 744         if (fk.basic.n_proto != htons(ETH_P_IP) &&
 745             fk.basic.n_proto != htons(ETH_P_IPV6))
 746                 return -EPROTONOSUPPORT;
 747
 748         if (skb->encapsulation)
 749                 return -EPROTONOSUPPORT;
 750
 751         arfs_t = arfs_get_table(arfs, fk.basic.ip_proto, fk.basic.n_proto);
 752         if (!arfs_t)
 753                 return -EPROTONOSUPPORT;
 754
 755         spin_lock_bh(&arfs->arfs_lock);
 756         arfs_rule = arfs_find_rule(arfs_t, &fk);
 757         if (arfs_rule) {
 758                 if (arfs_rule->rxq == rxq_index || work_busy(&arfs_rule->arfs_work)) {
 759                         spin_unlock_bh(&arfs->arfs_lock);
 760                         return arfs_rule->filter_id;
 761                 }
 762
 763                 priv->channel_stats[rxq_index]->rq.arfs_request_in++;
 764                 priv->channel_stats[arfs_rule->rxq]->rq.arfs_request_out++;
 765                 arfs_rule->rxq = rxq_index;
 766         } else {
 767                 arfs_rule = arfs_alloc_rule(priv, arfs_t, &fk, rxq_index, flow_id);
 768                 if (!arfs_rule) {
 769                         spin_unlock_bh(&arfs->arfs_lock);
 770                         return -ENOMEM;
 771                 }
 772         }
 773         queue_work(arfs->wq, &arfs_rule->arfs_work);
 774         spin_unlock_bh(&arfs->arfs_lock);
 775         return arfs_rule->filter_id;
 776 }
 777