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