drivers/infiniband/hw/mlx5/fs.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * Copyright (c) 2018, Mellanox Technologies inc.  All rights reserved.
   4  */
   5
   6 #include <rdma/ib_user_verbs.h>
   7 #include <rdma/ib_verbs.h>
   8 #include <rdma/uverbs_types.h>
   9 #include <rdma/uverbs_ioctl.h>
  10 #include <rdma/uverbs_std_types.h>
  11 #include <rdma/mlx5_user_ioctl_cmds.h>
  12 #include <rdma/mlx5_user_ioctl_verbs.h>
  13 #include <rdma/ib_hdrs.h>
  14 #include <rdma/ib_umem.h>
  15 #include <linux/mlx5/driver.h>
  16 #include <linux/mlx5/fs.h>
  17 #include <linux/mlx5/fs_helpers.h>
  18 #include <linux/mlx5/accel.h>
  19 #include <linux/mlx5/eswitch.h>
  20 #include <net/inet_ecn.h>
  21 #include "mlx5_ib.h"
  22 #include "counters.h"
  23 #include "devx.h"
  24 #include "fs.h"
  25
  26 #define UVERBS_MODULE_NAME mlx5_ib
  27 #include <rdma/uverbs_named_ioctl.h>
  28
  29 enum {
  30         MATCH_CRITERIA_ENABLE_OUTER_BIT,
  31         MATCH_CRITERIA_ENABLE_MISC_BIT,
  32         MATCH_CRITERIA_ENABLE_INNER_BIT,
  33         MATCH_CRITERIA_ENABLE_MISC2_BIT
  34 };
  35
  36 #define HEADER_IS_ZERO(match_criteria, headers)                            \
  37         !(memchr_inv(MLX5_ADDR_OF(fte_match_param, match_criteria, headers), \
  38                     0, MLX5_FLD_SZ_BYTES(fte_match_param, headers)))       \
  39
  40 static u8 get_match_criteria_enable(u32 *match_criteria)
  41 {
  42         u8 match_criteria_enable;
  43
  44         match_criteria_enable =
  45                 (!HEADER_IS_ZERO(match_criteria, outer_headers)) <<
  46                 MATCH_CRITERIA_ENABLE_OUTER_BIT;
  47         match_criteria_enable |=
  48                 (!HEADER_IS_ZERO(match_criteria, misc_parameters)) <<
  49                 MATCH_CRITERIA_ENABLE_MISC_BIT;
  50         match_criteria_enable |=
  51                 (!HEADER_IS_ZERO(match_criteria, inner_headers)) <<
  52                 MATCH_CRITERIA_ENABLE_INNER_BIT;
  53         match_criteria_enable |=
  54                 (!HEADER_IS_ZERO(match_criteria, misc_parameters_2)) <<
  55                 MATCH_CRITERIA_ENABLE_MISC2_BIT;
  56
  57         return match_criteria_enable;
  58 }
  59
  60 static int set_proto(void *outer_c, void *outer_v, u8 mask, u8 val)
  61 {
  62         u8 entry_mask;
  63         u8 entry_val;
  64         int err = 0;
  65
  66         if (!mask)
  67                 goto out;
  68
  69         entry_mask = MLX5_GET(fte_match_set_lyr_2_4, outer_c,
  70                               ip_protocol);
  71         entry_val = MLX5_GET(fte_match_set_lyr_2_4, outer_v,
  72                              ip_protocol);
  73         if (!entry_mask) {
  74                 MLX5_SET(fte_match_set_lyr_2_4, outer_c, ip_protocol, mask);
  75                 MLX5_SET(fte_match_set_lyr_2_4, outer_v, ip_protocol, val);
  76                 goto out;
  77         }
  78         /* Don't override existing ip protocol */
  79         if (mask != entry_mask || val != entry_val)
  80                 err = -EINVAL;
  81 out:
  82         return err;
  83 }
  84
  85 static void set_flow_label(void *misc_c, void *misc_v, u32 mask, u32 val,
  86                            bool inner)
  87 {
  88         if (inner) {
  89                 MLX5_SET(fte_match_set_misc,
  90                          misc_c, inner_ipv6_flow_label, mask);
  91                 MLX5_SET(fte_match_set_misc,
  92                          misc_v, inner_ipv6_flow_label, val);
  93         } else {
  94                 MLX5_SET(fte_match_set_misc,
  95                          misc_c, outer_ipv6_flow_label, mask);
  96                 MLX5_SET(fte_match_set_misc,
  97                          misc_v, outer_ipv6_flow_label, val);
  98         }
  99 }
 100
 101 static void set_tos(void *outer_c, void *outer_v, u8 mask, u8 val)
 102 {
 103         MLX5_SET(fte_match_set_lyr_2_4, outer_c, ip_ecn, mask);
 104         MLX5_SET(fte_match_set_lyr_2_4, outer_v, ip_ecn, val);
 105         MLX5_SET(fte_match_set_lyr_2_4, outer_c, ip_dscp, mask >> 2);
 106         MLX5_SET(fte_match_set_lyr_2_4, outer_v, ip_dscp, val >> 2);
 107 }
 108
 109 static int check_mpls_supp_fields(u32 field_support, const __be32 *set_mask)
 110 {
 111         if (MLX5_GET(fte_match_mpls, set_mask, mpls_label) &&
 112             !(field_support & MLX5_FIELD_SUPPORT_MPLS_LABEL))
 113                 return -EOPNOTSUPP;
 114
 115         if (MLX5_GET(fte_match_mpls, set_mask, mpls_exp) &&
 116             !(field_support & MLX5_FIELD_SUPPORT_MPLS_EXP))
 117                 return -EOPNOTSUPP;
 118
 119         if (MLX5_GET(fte_match_mpls, set_mask, mpls_s_bos) &&
 120             !(field_support & MLX5_FIELD_SUPPORT_MPLS_S_BOS))
 121                 return -EOPNOTSUPP;
 122
 123         if (MLX5_GET(fte_match_mpls, set_mask, mpls_ttl) &&
 124             !(field_support & MLX5_FIELD_SUPPORT_MPLS_TTL))
 125                 return -EOPNOTSUPP;
 126
 127         return 0;
 128 }
 129
 130 #define LAST_ETH_FIELD vlan_tag
 131 #define LAST_IB_FIELD sl
 132 #define LAST_IPV4_FIELD tos
 133 #define LAST_IPV6_FIELD traffic_class
 134 #define LAST_TCP_UDP_FIELD src_port
 135 #define LAST_TUNNEL_FIELD tunnel_id
 136 #define LAST_FLOW_TAG_FIELD tag_id
 137 #define LAST_DROP_FIELD size
 138 #define LAST_COUNTERS_FIELD counters
 139
 140 /* Field is the last supported field */
 141 #define FIELDS_NOT_SUPPORTED(filter, field)                                    \
 142         memchr_inv((void *)&filter.field + sizeof(filter.field), 0,            \
 143                    sizeof(filter) - offsetofend(typeof(filter), field))
 144
 145 int parse_flow_flow_action(struct mlx5_ib_flow_action *maction,
 146                            bool is_egress,
 147                            struct mlx5_flow_act *action)
 148 {
 149
 150         switch (maction->ib_action.type) {
 151         case IB_FLOW_ACTION_ESP:
 152                 if (action->action & (MLX5_FLOW_CONTEXT_ACTION_ENCRYPT |
 153                                       MLX5_FLOW_CONTEXT_ACTION_DECRYPT))
 154                         return -EINVAL;
 155                 /* Currently only AES_GCM keymat is supported by the driver */
 156                 action->esp_id = (uintptr_t)maction->esp_aes_gcm.ctx;
 157                 action->action |= is_egress ?
 158                         MLX5_FLOW_CONTEXT_ACTION_ENCRYPT :
 159                         MLX5_FLOW_CONTEXT_ACTION_DECRYPT;
 160                 return 0;
 161         case IB_FLOW_ACTION_UNSPECIFIED:
 162                 if (maction->flow_action_raw.sub_type ==
 163                     MLX5_IB_FLOW_ACTION_MODIFY_HEADER) {
 164                         if (action->action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR)
 165                                 return -EINVAL;
 166                         action->action |= MLX5_FLOW_CONTEXT_ACTION_MOD_HDR;
 167                         action->modify_hdr =
 168                                 maction->flow_action_raw.modify_hdr;
 169                         return 0;
 170                 }
 171                 if (maction->flow_action_raw.sub_type ==
 172                     MLX5_IB_FLOW_ACTION_DECAP) {
 173                         if (action->action & MLX5_FLOW_CONTEXT_ACTION_DECAP)
 174                                 return -EINVAL;
 175                         action->action |= MLX5_FLOW_CONTEXT_ACTION_DECAP;
 176                         return 0;
 177                 }
 178                 if (maction->flow_action_raw.sub_type ==
 179                     MLX5_IB_FLOW_ACTION_PACKET_REFORMAT) {
 180                         if (action->action &
 181                             MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT)
 182                                 return -EINVAL;
 183                         action->action |=
 184                                 MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT;
 185                         action->pkt_reformat =
 186                                 maction->flow_action_raw.pkt_reformat;
 187                         return 0;
 188                 }
 189                 fallthrough;
 190         default:
 191                 return -EOPNOTSUPP;
 192         }
 193 }
 194
 195 static int parse_flow_attr(struct mlx5_core_dev *mdev,
 196                            struct mlx5_flow_spec *spec,
 197                            const union ib_flow_spec *ib_spec,
 198                            const struct ib_flow_attr *flow_attr,
 199                            struct mlx5_flow_act *action, u32 prev_type)
 200 {
 201         struct mlx5_flow_context *flow_context = &spec->flow_context;
 202         u32 *match_c = spec->match_criteria;
 203         u32 *match_v = spec->match_value;
 204         void *misc_params_c = MLX5_ADDR_OF(fte_match_param, match_c,
 205                                            misc_parameters);
 206         void *misc_params_v = MLX5_ADDR_OF(fte_match_param, match_v,
 207                                            misc_parameters);
 208         void *misc_params2_c = MLX5_ADDR_OF(fte_match_param, match_c,
 209                                             misc_parameters_2);
 210         void *misc_params2_v = MLX5_ADDR_OF(fte_match_param, match_v,
 211                                             misc_parameters_2);
 212         void *headers_c;
 213         void *headers_v;
 214         int match_ipv;
 215         int ret;
 216
 217         if (ib_spec->type & IB_FLOW_SPEC_INNER) {
 218                 headers_c = MLX5_ADDR_OF(fte_match_param, match_c,
 219                                          inner_headers);
 220                 headers_v = MLX5_ADDR_OF(fte_match_param, match_v,
 221                                          inner_headers);
 222                 match_ipv = MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 223                                         ft_field_support.inner_ip_version);
 224         } else {
 225                 headers_c = MLX5_ADDR_OF(fte_match_param, match_c,
 226                                          outer_headers);
 227                 headers_v = MLX5_ADDR_OF(fte_match_param, match_v,
 228                                          outer_headers);
 229                 match_ipv = MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 230                                         ft_field_support.outer_ip_version);
 231         }
 232
 233         switch (ib_spec->type & ~IB_FLOW_SPEC_INNER) {
 234         case IB_FLOW_SPEC_ETH:
 235                 if (FIELDS_NOT_SUPPORTED(ib_spec->eth.mask, LAST_ETH_FIELD))
 236                         return -EOPNOTSUPP;
 237
 238                 ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 239                                              dmac_47_16),
 240                                 ib_spec->eth.mask.dst_mac);
 241                 ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 242                                              dmac_47_16),
 243                                 ib_spec->eth.val.dst_mac);
 244
 245                 ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 246                                              smac_47_16),
 247                                 ib_spec->eth.mask.src_mac);
 248                 ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 249                                              smac_47_16),
 250                                 ib_spec->eth.val.src_mac);
 251
 252                 if (ib_spec->eth.mask.vlan_tag) {
 253                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 254                                  cvlan_tag, 1);
 255                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 256                                  cvlan_tag, 1);
 257
 258                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 259                                  first_vid, ntohs(ib_spec->eth.mask.vlan_tag));
 260                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 261                                  first_vid, ntohs(ib_spec->eth.val.vlan_tag));
 262
 263                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 264                                  first_cfi,
 265                                  ntohs(ib_spec->eth.mask.vlan_tag) >> 12);
 266                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 267                                  first_cfi,
 268                                  ntohs(ib_spec->eth.val.vlan_tag) >> 12);
 269
 270                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 271                                  first_prio,
 272                                  ntohs(ib_spec->eth.mask.vlan_tag) >> 13);
 273                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 274                                  first_prio,
 275                                  ntohs(ib_spec->eth.val.vlan_tag) >> 13);
 276                 }
 277                 MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 278                          ethertype, ntohs(ib_spec->eth.mask.ether_type));
 279                 MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 280                          ethertype, ntohs(ib_spec->eth.val.ether_type));
 281                 break;
 282         case IB_FLOW_SPEC_IPV4:
 283                 if (FIELDS_NOT_SUPPORTED(ib_spec->ipv4.mask, LAST_IPV4_FIELD))
 284                         return -EOPNOTSUPP;
 285
 286                 if (match_ipv) {
 287                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 288                                  ip_version, 0xf);
 289                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 290                                  ip_version, MLX5_FS_IPV4_VERSION);
 291                 } else {
 292                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 293                                  ethertype, 0xffff);
 294                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 295                                  ethertype, ETH_P_IP);
 296                 }
 297
 298                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 299                                     src_ipv4_src_ipv6.ipv4_layout.ipv4),
 300                        &ib_spec->ipv4.mask.src_ip,
 301                        sizeof(ib_spec->ipv4.mask.src_ip));
 302                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 303                                     src_ipv4_src_ipv6.ipv4_layout.ipv4),
 304                        &ib_spec->ipv4.val.src_ip,
 305                        sizeof(ib_spec->ipv4.val.src_ip));
 306                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 307                                     dst_ipv4_dst_ipv6.ipv4_layout.ipv4),
 308                        &ib_spec->ipv4.mask.dst_ip,
 309                        sizeof(ib_spec->ipv4.mask.dst_ip));
 310                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 311                                     dst_ipv4_dst_ipv6.ipv4_layout.ipv4),
 312                        &ib_spec->ipv4.val.dst_ip,
 313                        sizeof(ib_spec->ipv4.val.dst_ip));
 314
 315                 set_tos(headers_c, headers_v,
 316                         ib_spec->ipv4.mask.tos, ib_spec->ipv4.val.tos);
 317
 318                 if (set_proto(headers_c, headers_v,
 319                               ib_spec->ipv4.mask.proto,
 320                               ib_spec->ipv4.val.proto))
 321                         return -EINVAL;
 322                 break;
 323         case IB_FLOW_SPEC_IPV6:
 324                 if (FIELDS_NOT_SUPPORTED(ib_spec->ipv6.mask, LAST_IPV6_FIELD))
 325                         return -EOPNOTSUPP;
 326
 327                 if (match_ipv) {
 328                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 329                                  ip_version, 0xf);
 330                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 331                                  ip_version, MLX5_FS_IPV6_VERSION);
 332                 } else {
 333                         MLX5_SET(fte_match_set_lyr_2_4, headers_c,
 334                                  ethertype, 0xffff);
 335                         MLX5_SET(fte_match_set_lyr_2_4, headers_v,
 336                                  ethertype, ETH_P_IPV6);
 337                 }
 338
 339                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 340                                     src_ipv4_src_ipv6.ipv6_layout.ipv6),
 341                        &ib_spec->ipv6.mask.src_ip,
 342                        sizeof(ib_spec->ipv6.mask.src_ip));
 343                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 344                                     src_ipv4_src_ipv6.ipv6_layout.ipv6),
 345                        &ib_spec->ipv6.val.src_ip,
 346                        sizeof(ib_spec->ipv6.val.src_ip));
 347                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
 348                                     dst_ipv4_dst_ipv6.ipv6_layout.ipv6),
 349                        &ib_spec->ipv6.mask.dst_ip,
 350                        sizeof(ib_spec->ipv6.mask.dst_ip));
 351                 memcpy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
 352                                     dst_ipv4_dst_ipv6.ipv6_layout.ipv6),
 353                        &ib_spec->ipv6.val.dst_ip,
 354                        sizeof(ib_spec->ipv6.val.dst_ip));
 355
 356                 set_tos(headers_c, headers_v,
 357                         ib_spec->ipv6.mask.traffic_class,
 358                         ib_spec->ipv6.val.traffic_class);
 359
 360                 if (set_proto(headers_c, headers_v,
 361                               ib_spec->ipv6.mask.next_hdr,
 362                               ib_spec->ipv6.val.next_hdr))
 363                         return -EINVAL;
 364
 365                 set_flow_label(misc_params_c, misc_params_v,
 366                                ntohl(ib_spec->ipv6.mask.flow_label),
 367                                ntohl(ib_spec->ipv6.val.flow_label),
 368                                ib_spec->type & IB_FLOW_SPEC_INNER);
 369                 break;
 370         case IB_FLOW_SPEC_ESP:
 371                 if (ib_spec->esp.mask.seq)
 372                         return -EOPNOTSUPP;
 373
 374                 MLX5_SET(fte_match_set_misc, misc_params_c, outer_esp_spi,
 375                          ntohl(ib_spec->esp.mask.spi));
 376                 MLX5_SET(fte_match_set_misc, misc_params_v, outer_esp_spi,
 377                          ntohl(ib_spec->esp.val.spi));
 378                 break;
 379         case IB_FLOW_SPEC_TCP:
 380                 if (FIELDS_NOT_SUPPORTED(ib_spec->tcp_udp.mask,
 381                                          LAST_TCP_UDP_FIELD))
 382                         return -EOPNOTSUPP;
 383
 384                 if (set_proto(headers_c, headers_v, 0xff, IPPROTO_TCP))
 385                         return -EINVAL;
 386
 387                 MLX5_SET(fte_match_set_lyr_2_4, headers_c, tcp_sport,
 388                          ntohs(ib_spec->tcp_udp.mask.src_port));
 389                 MLX5_SET(fte_match_set_lyr_2_4, headers_v, tcp_sport,
 390                          ntohs(ib_spec->tcp_udp.val.src_port));
 391
 392                 MLX5_SET(fte_match_set_lyr_2_4, headers_c, tcp_dport,
 393                          ntohs(ib_spec->tcp_udp.mask.dst_port));
 394                 MLX5_SET(fte_match_set_lyr_2_4, headers_v, tcp_dport,
 395                          ntohs(ib_spec->tcp_udp.val.dst_port));
 396                 break;
 397         case IB_FLOW_SPEC_UDP:
 398                 if (FIELDS_NOT_SUPPORTED(ib_spec->tcp_udp.mask,
 399                                          LAST_TCP_UDP_FIELD))
 400                         return -EOPNOTSUPP;
 401
 402                 if (set_proto(headers_c, headers_v, 0xff, IPPROTO_UDP))
 403                         return -EINVAL;
 404
 405                 MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_sport,
 406                          ntohs(ib_spec->tcp_udp.mask.src_port));
 407                 MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_sport,
 408                          ntohs(ib_spec->tcp_udp.val.src_port));
 409
 410                 MLX5_SET(fte_match_set_lyr_2_4, headers_c, udp_dport,
 411                          ntohs(ib_spec->tcp_udp.mask.dst_port));
 412                 MLX5_SET(fte_match_set_lyr_2_4, headers_v, udp_dport,
 413                          ntohs(ib_spec->tcp_udp.val.dst_port));
 414                 break;
 415         case IB_FLOW_SPEC_GRE:
 416                 if (ib_spec->gre.mask.c_ks_res0_ver)
 417                         return -EOPNOTSUPP;
 418
 419                 if (set_proto(headers_c, headers_v, 0xff, IPPROTO_GRE))
 420                         return -EINVAL;
 421
 422                 MLX5_SET(fte_match_set_lyr_2_4, headers_c, ip_protocol,
 423                          0xff);
 424                 MLX5_SET(fte_match_set_lyr_2_4, headers_v, ip_protocol,
 425                          IPPROTO_GRE);
 426
 427                 MLX5_SET(fte_match_set_misc, misc_params_c, gre_protocol,
 428                          ntohs(ib_spec->gre.mask.protocol));
 429                 MLX5_SET(fte_match_set_misc, misc_params_v, gre_protocol,
 430                          ntohs(ib_spec->gre.val.protocol));
 431
 432                 memcpy(MLX5_ADDR_OF(fte_match_set_misc, misc_params_c,
 433                                     gre_key.nvgre.hi),
 434                        &ib_spec->gre.mask.key,
 435                        sizeof(ib_spec->gre.mask.key));
 436                 memcpy(MLX5_ADDR_OF(fte_match_set_misc, misc_params_v,
 437                                     gre_key.nvgre.hi),
 438                        &ib_spec->gre.val.key,
 439                        sizeof(ib_spec->gre.val.key));
 440                 break;
 441         case IB_FLOW_SPEC_MPLS:
 442                 switch (prev_type) {
 443                 case IB_FLOW_SPEC_UDP:
 444                         if (check_mpls_supp_fields(MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 445                                                    ft_field_support.outer_first_mpls_over_udp),
 446                                                    &ib_spec->mpls.mask.tag))
 447                                 return -EOPNOTSUPP;
 448
 449                         memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_v,
 450                                             outer_first_mpls_over_udp),
 451                                &ib_spec->mpls.val.tag,
 452                                sizeof(ib_spec->mpls.val.tag));
 453                         memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_c,
 454                                             outer_first_mpls_over_udp),
 455                                &ib_spec->mpls.mask.tag,
 456                                sizeof(ib_spec->mpls.mask.tag));
 457                         break;
 458                 case IB_FLOW_SPEC_GRE:
 459                         if (check_mpls_supp_fields(MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 460                                                    ft_field_support.outer_first_mpls_over_gre),
 461                                                    &ib_spec->mpls.mask.tag))
 462                                 return -EOPNOTSUPP;
 463
 464                         memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_v,
 465                                             outer_first_mpls_over_gre),
 466                                &ib_spec->mpls.val.tag,
 467                                sizeof(ib_spec->mpls.val.tag));
 468                         memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_c,
 469                                             outer_first_mpls_over_gre),
 470                                &ib_spec->mpls.mask.tag,
 471                                sizeof(ib_spec->mpls.mask.tag));
 472                         break;
 473                 default:
 474                         if (ib_spec->type & IB_FLOW_SPEC_INNER) {
 475                                 if (check_mpls_supp_fields(MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 476                                                            ft_field_support.inner_first_mpls),
 477                                                            &ib_spec->mpls.mask.tag))
 478                                         return -EOPNOTSUPP;
 479
 480                                 memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_v,
 481                                                     inner_first_mpls),
 482                                        &ib_spec->mpls.val.tag,
 483                                        sizeof(ib_spec->mpls.val.tag));
 484                                 memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_c,
 485                                                     inner_first_mpls),
 486                                        &ib_spec->mpls.mask.tag,
 487                                        sizeof(ib_spec->mpls.mask.tag));
 488                         } else {
 489                                 if (check_mpls_supp_fields(MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 490                                                            ft_field_support.outer_first_mpls),
 491                                                            &ib_spec->mpls.mask.tag))
 492                                         return -EOPNOTSUPP;
 493
 494                                 memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_v,
 495                                                     outer_first_mpls),
 496                                        &ib_spec->mpls.val.tag,
 497                                        sizeof(ib_spec->mpls.val.tag));
 498                                 memcpy(MLX5_ADDR_OF(fte_match_set_misc2, misc_params2_c,
 499                                                     outer_first_mpls),
 500                                        &ib_spec->mpls.mask.tag,
 501                                        sizeof(ib_spec->mpls.mask.tag));
 502                         }
 503                 }
 504                 break;
 505         case IB_FLOW_SPEC_VXLAN_TUNNEL:
 506                 if (FIELDS_NOT_SUPPORTED(ib_spec->tunnel.mask,
 507                                          LAST_TUNNEL_FIELD))
 508                         return -EOPNOTSUPP;
 509
 510                 MLX5_SET(fte_match_set_misc, misc_params_c, vxlan_vni,
 511                          ntohl(ib_spec->tunnel.mask.tunnel_id));
 512                 MLX5_SET(fte_match_set_misc, misc_params_v, vxlan_vni,
 513                          ntohl(ib_spec->tunnel.val.tunnel_id));
 514                 break;
 515         case IB_FLOW_SPEC_ACTION_TAG:
 516                 if (FIELDS_NOT_SUPPORTED(ib_spec->flow_tag,
 517                                          LAST_FLOW_TAG_FIELD))
 518                         return -EOPNOTSUPP;
 519                 if (ib_spec->flow_tag.tag_id >= BIT(24))
 520                         return -EINVAL;
 521
 522                 flow_context->flow_tag = ib_spec->flow_tag.tag_id;
 523                 flow_context->flags |= FLOW_CONTEXT_HAS_TAG;
 524                 break;
 525         case IB_FLOW_SPEC_ACTION_DROP:
 526                 if (FIELDS_NOT_SUPPORTED(ib_spec->drop,
 527                                          LAST_DROP_FIELD))
 528                         return -EOPNOTSUPP;
 529                 action->action |= MLX5_FLOW_CONTEXT_ACTION_DROP;
 530                 break;
 531         case IB_FLOW_SPEC_ACTION_HANDLE:
 532                 ret = parse_flow_flow_action(to_mflow_act(ib_spec->action.act),
 533                         flow_attr->flags & IB_FLOW_ATTR_FLAGS_EGRESS, action);
 534                 if (ret)
 535                         return ret;
 536                 break;
 537         case IB_FLOW_SPEC_ACTION_COUNT:
 538                 if (FIELDS_NOT_SUPPORTED(ib_spec->flow_count,
 539                                          LAST_COUNTERS_FIELD))
 540                         return -EOPNOTSUPP;
 541
 542                 /* for now support only one counters spec per flow */
 543                 if (action->action & MLX5_FLOW_CONTEXT_ACTION_COUNT)
 544                         return -EINVAL;
 545
 546                 action->counters = ib_spec->flow_count.counters;
 547                 action->action |= MLX5_FLOW_CONTEXT_ACTION_COUNT;
 548                 break;
 549         default:
 550                 return -EINVAL;
 551         }
 552
 553         return 0;
 554 }
 555
 556 /* If a flow could catch both multicast and unicast packets,
 557  * it won't fall into the multicast flow steering table and this rule
 558  * could steal other multicast packets.
 559  */
 560 static bool flow_is_multicast_only(const struct ib_flow_attr *ib_attr)
 561 {
 562         union ib_flow_spec *flow_spec;
 563
 564         if (ib_attr->type != IB_FLOW_ATTR_NORMAL ||
 565             ib_attr->num_of_specs < 1)
 566                 return false;
 567
 568         flow_spec = (union ib_flow_spec *)(ib_attr + 1);
 569         if (flow_spec->type == IB_FLOW_SPEC_IPV4) {
 570                 struct ib_flow_spec_ipv4 *ipv4_spec;
 571
 572                 ipv4_spec = (struct ib_flow_spec_ipv4 *)flow_spec;
 573                 if (ipv4_is_multicast(ipv4_spec->val.dst_ip))
 574                         return true;
 575
 576                 return false;
 577         }
 578
 579         if (flow_spec->type == IB_FLOW_SPEC_ETH) {
 580                 struct ib_flow_spec_eth *eth_spec;
 581
 582                 eth_spec = (struct ib_flow_spec_eth *)flow_spec;
 583                 return is_multicast_ether_addr(eth_spec->mask.dst_mac) &&
 584                        is_multicast_ether_addr(eth_spec->val.dst_mac);
 585         }
 586
 587         return false;
 588 }
 589
 590 enum valid_spec {
 591         VALID_SPEC_INVALID,
 592         VALID_SPEC_VALID,
 593         VALID_SPEC_NA,
 594 };
 595
 596 static enum valid_spec
 597 is_valid_esp_aes_gcm(struct mlx5_core_dev *mdev,
 598                      const struct mlx5_flow_spec *spec,
 599                      const struct mlx5_flow_act *flow_act,
 600                      bool egress)
 601 {
 602         const u32 *match_c = spec->match_criteria;
 603         bool is_crypto =
 604                 (flow_act->action & (MLX5_FLOW_CONTEXT_ACTION_ENCRYPT |
 605                                      MLX5_FLOW_CONTEXT_ACTION_DECRYPT));
 606         bool is_ipsec = mlx5_fs_is_ipsec_flow(match_c);
 607         bool is_drop = flow_act->action & MLX5_FLOW_CONTEXT_ACTION_DROP;
 608
 609         /*
 610          * Currently only crypto is supported in egress, when regular egress
 611          * rules would be supported, always return VALID_SPEC_NA.
 612          */
 613         if (!is_crypto)
 614                 return VALID_SPEC_NA;
 615
 616         return is_crypto && is_ipsec &&
 617                 (!egress || (!is_drop &&
 618                              !(spec->flow_context.flags & FLOW_CONTEXT_HAS_TAG))) ?
 619                 VALID_SPEC_VALID : VALID_SPEC_INVALID;
 620 }
 621
 622 static bool is_valid_spec(struct mlx5_core_dev *mdev,
 623                           const struct mlx5_flow_spec *spec,
 624                           const struct mlx5_flow_act *flow_act,
 625                           bool egress)
 626 {
 627         /* We curretly only support ipsec egress flow */
 628         return is_valid_esp_aes_gcm(mdev, spec, flow_act, egress) != VALID_SPEC_INVALID;
 629 }
 630
 631 static bool is_valid_ethertype(struct mlx5_core_dev *mdev,
 632                                const struct ib_flow_attr *flow_attr,
 633                                bool check_inner)
 634 {
 635         union ib_flow_spec *ib_spec = (union ib_flow_spec *)(flow_attr + 1);
 636         int match_ipv = check_inner ?
 637                         MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 638                                         ft_field_support.inner_ip_version) :
 639                         MLX5_CAP_FLOWTABLE_NIC_RX(mdev,
 640                                         ft_field_support.outer_ip_version);
 641         int inner_bit = check_inner ? IB_FLOW_SPEC_INNER : 0;
 642         bool ipv4_spec_valid, ipv6_spec_valid;
 643         unsigned int ip_spec_type = 0;
 644         bool has_ethertype = false;
 645         unsigned int spec_index;
 646         bool mask_valid = true;
 647         u16 eth_type = 0;
 648         bool type_valid;
 649
 650         /* Validate that ethertype is correct */
 651         for (spec_index = 0; spec_index < flow_attr->num_of_specs; spec_index++) {
 652                 if ((ib_spec->type == (IB_FLOW_SPEC_ETH | inner_bit)) &&
 653                     ib_spec->eth.mask.ether_type) {
 654                         mask_valid = (ib_spec->eth.mask.ether_type ==
 655                                       htons(0xffff));
 656                         has_ethertype = true;
 657                         eth_type = ntohs(ib_spec->eth.val.ether_type);
 658                 } else if ((ib_spec->type == (IB_FLOW_SPEC_IPV4 | inner_bit)) ||
 659                            (ib_spec->type == (IB_FLOW_SPEC_IPV6 | inner_bit))) {
 660                         ip_spec_type = ib_spec->type;
 661                 }
 662                 ib_spec = (void *)ib_spec + ib_spec->size;
 663         }
 664
 665         type_valid = (!has_ethertype) || (!ip_spec_type);
 666         if (!type_valid && mask_valid) {
 667                 ipv4_spec_valid = (eth_type == ETH_P_IP) &&
 668                         (ip_spec_type == (IB_FLOW_SPEC_IPV4 | inner_bit));
 669                 ipv6_spec_valid = (eth_type == ETH_P_IPV6) &&
 670                         (ip_spec_type == (IB_FLOW_SPEC_IPV6 | inner_bit));
 671
 672                 type_valid = (ipv4_spec_valid) || (ipv6_spec_valid) ||
 673                              (((eth_type == ETH_P_MPLS_UC) ||
 674                                (eth_type == ETH_P_MPLS_MC)) && match_ipv);
 675         }
 676
 677         return type_valid;
 678 }
 679
 680 static bool is_valid_attr(struct mlx5_core_dev *mdev,
 681                           const struct ib_flow_attr *flow_attr)
 682 {
 683         return is_valid_ethertype(mdev, flow_attr, false) &&
 684                is_valid_ethertype(mdev, flow_attr, true);
 685 }
 686
 687 static void put_flow_table(struct mlx5_ib_dev *dev,
 688                            struct mlx5_ib_flow_prio *prio, bool ft_added)
 689 {
 690         prio->refcount -= !!ft_added;
 691         if (!prio->refcount) {
 692                 mlx5_destroy_flow_table(prio->flow_table);
 693                 prio->flow_table = NULL;
 694         }
 695 }
 696
 697 static int mlx5_ib_destroy_flow(struct ib_flow *flow_id)
 698 {
 699         struct mlx5_ib_flow_handler *handler = container_of(flow_id,
 700                                                           struct mlx5_ib_flow_handler,
 701                                                           ibflow);
 702         struct mlx5_ib_flow_handler *iter, *tmp;
 703         struct mlx5_ib_dev *dev = handler->dev;
 704
 705         mutex_lock(&dev->flow_db->lock);
 706
 707         list_for_each_entry_safe(iter, tmp, &handler->list, list) {
 708                 mlx5_del_flow_rules(iter->rule);
 709                 put_flow_table(dev, iter->prio, true);
 710                 list_del(&iter->list);
 711                 kfree(iter);
 712         }
 713
 714         mlx5_del_flow_rules(handler->rule);
 715         put_flow_table(dev, handler->prio, true);
 716         mlx5_ib_counters_clear_description(handler->ibcounters);
 717         mutex_unlock(&dev->flow_db->lock);
 718         if (handler->flow_matcher)
 719                 atomic_dec(&handler->flow_matcher->usecnt);
 720         kfree(handler);
 721
 722         return 0;
 723 }
 724
 725 static int ib_prio_to_core_prio(unsigned int priority, bool dont_trap)
 726 {
 727         priority *= 2;
 728         if (!dont_trap)
 729                 priority++;
 730         return priority;
 731 }
 732
 733 enum flow_table_type {
 734         MLX5_IB_FT_RX,
 735         MLX5_IB_FT_TX
 736 };
 737
 738 #define MLX5_FS_MAX_TYPES        6
 739 #define MLX5_FS_MAX_ENTRIES      BIT(16)
 740
 741 static struct mlx5_ib_flow_prio *_get_prio(struct mlx5_flow_namespace *ns,
 742                                            struct mlx5_ib_flow_prio *prio,
 743                                            int priority,
 744                                            int num_entries, int num_groups,
 745                                            u32 flags)
 746 {
 747         struct mlx5_flow_table_attr ft_attr = {};
 748         struct mlx5_flow_table *ft;
 749
 750         ft_attr.prio = priority;
 751         ft_attr.max_fte = num_entries;
 752         ft_attr.flags = flags;
 753         ft_attr.autogroup.max_num_groups = num_groups;
 754         ft = mlx5_create_auto_grouped_flow_table(ns, &ft_attr);
 755         if (IS_ERR(ft))
 756                 return ERR_CAST(ft);
 757
 758         prio->flow_table = ft;
 759         prio->refcount = 0;
 760         return prio;
 761 }
 762
 763 static struct mlx5_ib_flow_prio *get_flow_table(struct mlx5_ib_dev *dev,
 764                                                 struct ib_flow_attr *flow_attr,
 765                                                 enum flow_table_type ft_type)
 766 {
 767         bool dont_trap = flow_attr->flags & IB_FLOW_ATTR_FLAGS_DONT_TRAP;
 768         struct mlx5_flow_namespace *ns = NULL;
 769         enum mlx5_flow_namespace_type fn_type;
 770         struct mlx5_ib_flow_prio *prio;
 771         struct mlx5_flow_table *ft;
 772         int max_table_size;
 773         int num_entries;
 774         int num_groups;
 775         bool esw_encap;
 776         u32 flags = 0;
 777         int priority;
 778
 779         max_table_size = BIT(MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev,
 780                                                        log_max_ft_size));
 781         esw_encap = mlx5_eswitch_get_encap_mode(dev->mdev) !=
 782                 DEVLINK_ESWITCH_ENCAP_MODE_NONE;
 783         switch (flow_attr->type) {
 784         case IB_FLOW_ATTR_NORMAL:
 785                 if (flow_is_multicast_only(flow_attr) && !dont_trap)
 786                         priority = MLX5_IB_FLOW_MCAST_PRIO;
 787                 else
 788                         priority = ib_prio_to_core_prio(flow_attr->priority,
 789                                                         dont_trap);
 790                 if (ft_type == MLX5_IB_FT_RX) {
 791                         fn_type = MLX5_FLOW_NAMESPACE_BYPASS;
 792                         prio = &dev->flow_db->prios[priority];
 793                         if (!dev->is_rep && !esw_encap &&
 794                             MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev, decap))
 795                                 flags |= MLX5_FLOW_TABLE_TUNNEL_EN_DECAP;
 796                         if (!dev->is_rep && !esw_encap &&
 797                             MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev,
 798                                                       reformat_l3_tunnel_to_l2))
 799                                 flags |= MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT;
 800                 } else {
 801                         max_table_size = BIT(MLX5_CAP_FLOWTABLE_NIC_TX(
 802                                 dev->mdev, log_max_ft_size));
 803                         fn_type = MLX5_FLOW_NAMESPACE_EGRESS;
 804                         prio = &dev->flow_db->egress_prios[priority];
 805                         if (!dev->is_rep && !esw_encap &&
 806                             MLX5_CAP_FLOWTABLE_NIC_TX(dev->mdev, reformat))
 807                                 flags |= MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT;
 808                 }
 809                 ns = mlx5_get_flow_namespace(dev->mdev, fn_type);
 810                 num_entries = MLX5_FS_MAX_ENTRIES;
 811                 num_groups = MLX5_FS_MAX_TYPES;
 812                 break;
 813         case IB_FLOW_ATTR_ALL_DEFAULT:
 814         case IB_FLOW_ATTR_MC_DEFAULT:
 815                 ns = mlx5_get_flow_namespace(dev->mdev,
 816                                              MLX5_FLOW_NAMESPACE_LEFTOVERS);
 817                 build_leftovers_ft_param(&priority, &num_entries, &num_groups);
 818                 prio = &dev->flow_db->prios[MLX5_IB_FLOW_LEFTOVERS_PRIO];
 819                 break;
 820         case IB_FLOW_ATTR_SNIFFER:
 821                 if (!MLX5_CAP_FLOWTABLE(dev->mdev,
 822                                         allow_sniffer_and_nic_rx_shared_tir))
 823                         return ERR_PTR(-EOPNOTSUPP);
 824
 825                 ns = mlx5_get_flow_namespace(
 826                         dev->mdev, ft_type == MLX5_IB_FT_RX ?
 827                                            MLX5_FLOW_NAMESPACE_SNIFFER_RX :
 828                                            MLX5_FLOW_NAMESPACE_SNIFFER_TX);
 829
 830                 prio = &dev->flow_db->sniffer[ft_type];
 831                 priority = 0;
 832                 num_entries = 1;
 833                 num_groups = 1;
 834                 break;
 835         default:
 836                 break;
 837         }
 838
 839         if (!ns)
 840                 return ERR_PTR(-EOPNOTSUPP);
 841
 842         max_table_size = min_t(int, num_entries, max_table_size);
 843
 844         ft = prio->flow_table;
 845         if (!ft)
 846                 return _get_prio(ns, prio, priority, max_table_size, num_groups,
 847                                  flags);
 848
 849         return prio;
 850 }
 851
 852 enum {
 853         RDMA_RX_ECN_OPCOUNTER_PRIO,
 854         RDMA_RX_CNP_OPCOUNTER_PRIO,
 855 };
 856
 857 enum {
 858         RDMA_TX_CNP_OPCOUNTER_PRIO,
 859 };
 860
 861 static int set_vhca_port_spec(struct mlx5_ib_dev *dev, u32 port_num,
 862                               struct mlx5_flow_spec *spec)
 863 {
 864         if (!MLX5_CAP_FLOWTABLE_RDMA_RX(dev->mdev,
 865                                         ft_field_support.source_vhca_port) ||
 866             !MLX5_CAP_FLOWTABLE_RDMA_TX(dev->mdev,
 867                                         ft_field_support.source_vhca_port))
 868                 return -EOPNOTSUPP;
 869
 870         MLX5_SET_TO_ONES(fte_match_param, &spec->match_criteria,
 871                          misc_parameters.source_vhca_port);
 872         MLX5_SET(fte_match_param, &spec->match_value,
 873                  misc_parameters.source_vhca_port, port_num);
 874
 875         return 0;
 876 }
 877
 878 static int set_ecn_ce_spec(struct mlx5_ib_dev *dev, u32 port_num,
 879                            struct mlx5_flow_spec *spec, int ipv)
 880 {
 881         if (!MLX5_CAP_FLOWTABLE_RDMA_RX(dev->mdev,
 882                                         ft_field_support.outer_ip_version))
 883                 return -EOPNOTSUPP;
 884
 885         if (mlx5_core_mp_enabled(dev->mdev) &&
 886             set_vhca_port_spec(dev, port_num, spec))
 887                 return -EOPNOTSUPP;
 888
 889         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 890                          outer_headers.ip_ecn);
 891         MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_ecn,
 892                  INET_ECN_CE);
 893         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 894                          outer_headers.ip_version);
 895         MLX5_SET(fte_match_param, spec->match_value, outer_headers.ip_version,
 896                  ipv);
 897
 898         spec->match_criteria_enable =
 899                 get_match_criteria_enable(spec->match_criteria);
 900
 901         return 0;
 902 }
 903
 904 static int set_cnp_spec(struct mlx5_ib_dev *dev, u32 port_num,
 905                         struct mlx5_flow_spec *spec)
 906 {
 907         if (mlx5_core_mp_enabled(dev->mdev) &&
 908             set_vhca_port_spec(dev, port_num, spec))
 909                 return -EOPNOTSUPP;
 910
 911         MLX5_SET_TO_ONES(fte_match_param, spec->match_criteria,
 912                          misc_parameters.bth_opcode);
 913         MLX5_SET(fte_match_param, spec->match_value, misc_parameters.bth_opcode,
 914                  IB_BTH_OPCODE_CNP);
 915
 916         spec->match_criteria_enable =
 917                 get_match_criteria_enable(spec->match_criteria);
 918
 919         return 0;
 920 }
 921
 922 int mlx5_ib_fs_add_op_fc(struct mlx5_ib_dev *dev, u32 port_num,
 923                          struct mlx5_ib_op_fc *opfc,
 924                          enum mlx5_ib_optional_counter_type type)
 925 {
 926         enum mlx5_flow_namespace_type fn_type;
 927         int priority, i, err, spec_num;
 928         struct mlx5_flow_act flow_act = {};
 929         struct mlx5_flow_destination dst;
 930         struct mlx5_flow_namespace *ns;
 931         struct mlx5_ib_flow_prio *prio;
 932         struct mlx5_flow_spec *spec;
 933
 934         spec = kcalloc(MAX_OPFC_RULES, sizeof(*spec), GFP_KERNEL);
 935         if (!spec)
 936                 return -ENOMEM;
 937
 938         switch (type) {
 939         case MLX5_IB_OPCOUNTER_CC_RX_CE_PKTS:
 940                 if (set_ecn_ce_spec(dev, port_num, &spec[0],
 941                                     MLX5_FS_IPV4_VERSION) ||
 942                     set_ecn_ce_spec(dev, port_num, &spec[1],
 943                                     MLX5_FS_IPV6_VERSION)) {
 944                         err = -EOPNOTSUPP;
 945                         goto free;
 946                 }
 947                 spec_num = 2;
 948                 fn_type = MLX5_FLOW_NAMESPACE_RDMA_RX_COUNTERS;
 949                 priority = RDMA_RX_ECN_OPCOUNTER_PRIO;
 950                 break;
 951
 952         case MLX5_IB_OPCOUNTER_CC_RX_CNP_PKTS:
 953                 if (!MLX5_CAP_FLOWTABLE(dev->mdev,
 954                                         ft_field_support_2_nic_receive_rdma.bth_opcode) ||
 955                     set_cnp_spec(dev, port_num, &spec[0])) {
 956                         err = -EOPNOTSUPP;
 957                         goto free;
 958                 }
 959                 spec_num = 1;
 960                 fn_type = MLX5_FLOW_NAMESPACE_RDMA_RX_COUNTERS;
 961                 priority = RDMA_RX_CNP_OPCOUNTER_PRIO;
 962                 break;
 963
 964         case MLX5_IB_OPCOUNTER_CC_TX_CNP_PKTS:
 965                 if (!MLX5_CAP_FLOWTABLE(dev->mdev,
 966                                         ft_field_support_2_nic_transmit_rdma.bth_opcode) ||
 967                     set_cnp_spec(dev, port_num, &spec[0])) {
 968                         err = -EOPNOTSUPP;
 969                         goto free;
 970                 }
 971                 spec_num = 1;
 972                 fn_type = MLX5_FLOW_NAMESPACE_RDMA_TX_COUNTERS;
 973                 priority = RDMA_TX_CNP_OPCOUNTER_PRIO;
 974                 break;
 975
 976         default:
 977                 err = -EOPNOTSUPP;
 978                 goto free;
 979         }
 980
 981         ns = mlx5_get_flow_namespace(dev->mdev, fn_type);
 982         if (!ns) {
 983                 err = -EOPNOTSUPP;
 984                 goto free;
 985         }
 986
 987         prio = &dev->flow_db->opfcs[type];
 988         if (!prio->flow_table) {
 989                 prio = _get_prio(ns, prio, priority,
 990                                  dev->num_ports * MAX_OPFC_RULES, 1, 0);
 991                 if (IS_ERR(prio)) {
 992                         err = PTR_ERR(prio);
 993                         goto free;
 994                 }
 995         }
 996
 997         dst.type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
 998         dst.counter_id = mlx5_fc_id(opfc->fc);
 999
1000         flow_act.action =
1001                 MLX5_FLOW_CONTEXT_ACTION_COUNT | MLX5_FLOW_CONTEXT_ACTION_ALLOW;
1002
1003         for (i = 0; i < spec_num; i++) {
1004                 opfc->rule[i] = mlx5_add_flow_rules(prio->flow_table, &spec[i],
1005                                                     &flow_act, &dst, 1);
1006                 if (IS_ERR(opfc->rule[i])) {
1007                         err = PTR_ERR(opfc->rule[i]);
1008                         goto del_rules;
1009                 }
1010         }
1011         prio->refcount += spec_num;
1012         kfree(spec);
1013
1014         return 0;
1015
1016 del_rules:
1017         for (i -= 1; i >= 0; i--)
1018                 mlx5_del_flow_rules(opfc->rule[i]);
1019         put_flow_table(dev, prio, false);
1020 free:
1021         kfree(spec);
1022         return err;
1023 }
1024
1025 void mlx5_ib_fs_remove_op_fc(struct mlx5_ib_dev *dev,
1026                              struct mlx5_ib_op_fc *opfc,
1027                              enum mlx5_ib_optional_counter_type type)
1028 {
1029         int i;
1030
1031         for (i = 0; i < MAX_OPFC_RULES && opfc->rule[i]; i++) {
1032                 mlx5_del_flow_rules(opfc->rule[i]);
1033                 put_flow_table(dev, &dev->flow_db->opfcs[type], true);
1034         }
1035 }
1036
1037 static void set_underlay_qp(struct mlx5_ib_dev *dev,
1038                             struct mlx5_flow_spec *spec,
1039                             u32 underlay_qpn)
1040 {
1041         void *misc_params_c = MLX5_ADDR_OF(fte_match_param,
1042                                            spec->match_criteria,
1043                                            misc_parameters);
1044         void *misc_params_v = MLX5_ADDR_OF(fte_match_param, spec->match_value,
1045                                            misc_parameters);
1046
1047         if (underlay_qpn &&
1048             MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev,
1049                                       ft_field_support.bth_dst_qp)) {
1050                 MLX5_SET(fte_match_set_misc,
1051                          misc_params_v, bth_dst_qp, underlay_qpn);
1052                 MLX5_SET(fte_match_set_misc,
1053                          misc_params_c, bth_dst_qp, 0xffffff);
1054         }
1055 }
1056
1057 static void mlx5_ib_set_rule_source_port(struct mlx5_ib_dev *dev,
1058                                          struct mlx5_flow_spec *spec,
1059                                          struct mlx5_eswitch_rep *rep)
1060 {
1061         struct mlx5_eswitch *esw = dev->mdev->priv.eswitch;
1062         void *misc;
1063
1064         if (mlx5_eswitch_vport_match_metadata_enabled(esw)) {
1065                 misc = MLX5_ADDR_OF(fte_match_param, spec->match_value,
1066                                     misc_parameters_2);
1067
1068                 MLX5_SET(fte_match_set_misc2, misc, metadata_reg_c_0,
1069                          mlx5_eswitch_get_vport_metadata_for_match(rep->esw,
1070                                                                    rep->vport));
1071                 misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
1072                                     misc_parameters_2);
1073
1074                 MLX5_SET(fte_match_set_misc2, misc, metadata_reg_c_0,
1075                          mlx5_eswitch_get_vport_metadata_mask());
1076         } else {
1077                 misc = MLX5_ADDR_OF(fte_match_param, spec->match_value,
1078                                     misc_parameters);
1079
1080                 MLX5_SET(fte_match_set_misc, misc, source_port, rep->vport);
1081
1082                 misc = MLX5_ADDR_OF(fte_match_param, spec->match_criteria,
1083                                     misc_parameters);
1084
1085                 MLX5_SET_TO_ONES(fte_match_set_misc, misc, source_port);
1086         }
1087 }
1088
1089 static struct mlx5_ib_flow_handler *_create_flow_rule(struct mlx5_ib_dev *dev,
1090                                                       struct mlx5_ib_flow_prio *ft_prio,
1091                                                       const struct ib_flow_attr *flow_attr,
1092                                                       struct mlx5_flow_destination *dst,
1093                                                       u32 underlay_qpn,
1094                                                       struct mlx5_ib_create_flow *ucmd)
1095 {
1096         struct mlx5_flow_table  *ft = ft_prio->flow_table;
1097         struct mlx5_ib_flow_handler *handler;
1098         struct mlx5_flow_act flow_act = {};
1099         struct mlx5_flow_spec *spec;
1100         struct mlx5_flow_destination dest_arr[2] = {};
1101         struct mlx5_flow_destination *rule_dst = dest_arr;
1102         const void *ib_flow = (const void *)flow_attr + sizeof(*flow_attr);
1103         unsigned int spec_index;
1104         u32 prev_type = 0;
1105         int err = 0;
1106         int dest_num = 0;
1107         bool is_egress = flow_attr->flags & IB_FLOW_ATTR_FLAGS_EGRESS;
1108
1109         if (!is_valid_attr(dev->mdev, flow_attr))
1110                 return ERR_PTR(-EINVAL);
1111
1112         if (dev->is_rep && is_egress)
1113                 return ERR_PTR(-EINVAL);
1114
1115         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
1116         handler = kzalloc(sizeof(*handler), GFP_KERNEL);
1117         if (!handler || !spec) {
1118                 err = -ENOMEM;
1119                 goto free;
1120         }
1121
1122         INIT_LIST_HEAD(&handler->list);
1123
1124         for (spec_index = 0; spec_index < flow_attr->num_of_specs; spec_index++) {
1125                 err = parse_flow_attr(dev->mdev, spec,
1126                                       ib_flow, flow_attr, &flow_act,
1127                                       prev_type);
1128                 if (err < 0)
1129                         goto free;
1130
1131                 prev_type = ((union ib_flow_spec *)ib_flow)->type;
1132                 ib_flow += ((union ib_flow_spec *)ib_flow)->size;
1133         }
1134
1135         if (dst && !(flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DROP)) {
1136                 memcpy(&dest_arr[0], dst, sizeof(*dst));
1137                 dest_num++;
1138         }
1139
1140         if (!flow_is_multicast_only(flow_attr))
1141                 set_underlay_qp(dev, spec, underlay_qpn);
1142
1143         if (dev->is_rep && flow_attr->type != IB_FLOW_ATTR_SNIFFER) {
1144                 struct mlx5_eswitch_rep *rep;
1145
1146                 rep = dev->port[flow_attr->port - 1].rep;
1147                 if (!rep) {
1148                         err = -EINVAL;
1149                         goto free;
1150                 }
1151
1152                 mlx5_ib_set_rule_source_port(dev, spec, rep);
1153         }
1154
1155         spec->match_criteria_enable = get_match_criteria_enable(spec->match_criteria);
1156
1157         if (is_egress &&
1158             !is_valid_spec(dev->mdev, spec, &flow_act, is_egress)) {
1159                 err = -EINVAL;
1160                 goto free;
1161         }
1162
1163         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {
1164                 struct mlx5_ib_mcounters *mcounters;
1165
1166                 err = mlx5_ib_flow_counters_set_data(flow_act.counters, ucmd);
1167                 if (err)
1168                         goto free;
1169
1170                 mcounters = to_mcounters(flow_act.counters);
1171                 handler->ibcounters = flow_act.counters;
1172                 dest_arr[dest_num].type =
1173                         MLX5_FLOW_DESTINATION_TYPE_COUNTER;
1174                 dest_arr[dest_num].counter_id =
1175                         mlx5_fc_id(mcounters->hw_cntrs_hndl);
1176                 dest_num++;
1177         }
1178
1179         if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DROP) {
1180                 if (!dest_num)
1181                         rule_dst = NULL;
1182         } else {
1183                 if (flow_attr->flags & IB_FLOW_ATTR_FLAGS_DONT_TRAP)
1184                         flow_act.action |=
1185                                 MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_PRIO;
1186                 if (is_egress)
1187                         flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_ALLOW;
1188                 else if (dest_num)
1189                         flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
1190         }
1191
1192         if ((spec->flow_context.flags & FLOW_CONTEXT_HAS_TAG)  &&
1193             (flow_attr->type == IB_FLOW_ATTR_ALL_DEFAULT ||
1194              flow_attr->type == IB_FLOW_ATTR_MC_DEFAULT)) {
1195                 mlx5_ib_warn(dev, "Flow tag %u and attribute type %x isn't allowed in leftovers\n",
1196                              spec->flow_context.flow_tag, flow_attr->type);
1197                 err = -EINVAL;
1198                 goto free;
1199         }
1200         handler->rule = mlx5_add_flow_rules(ft, spec,
1201                                             &flow_act,
1202                                             rule_dst, dest_num);
1203
1204         if (IS_ERR(handler->rule)) {
1205                 err = PTR_ERR(handler->rule);
1206                 goto free;
1207         }
1208
1209         ft_prio->refcount++;
1210         handler->prio = ft_prio;
1211         handler->dev = dev;
1212
1213         ft_prio->flow_table = ft;
1214 free:
1215         if (err && handler) {
1216                 mlx5_ib_counters_clear_description(handler->ibcounters);
1217                 kfree(handler);
1218         }
1219         kvfree(spec);
1220         return err ? ERR_PTR(err) : handler;
1221 }
1222
1223 static struct mlx5_ib_flow_handler *create_flow_rule(struct mlx5_ib_dev *dev,
1224                                                      struct mlx5_ib_flow_prio *ft_prio,
1225                                                      const struct ib_flow_attr *flow_attr,
1226                                                      struct mlx5_flow_destination *dst)
1227 {
1228         return _create_flow_rule(dev, ft_prio, flow_attr, dst, 0, NULL);
1229 }
1230
1231 enum {
1232         LEFTOVERS_MC,
1233         LEFTOVERS_UC,
1234 };
1235
1236 static struct mlx5_ib_flow_handler *create_leftovers_rule(struct mlx5_ib_dev *dev,
1237                                                           struct mlx5_ib_flow_prio *ft_prio,
1238                                                           struct ib_flow_attr *flow_attr,
1239                                                           struct mlx5_flow_destination *dst)
1240 {
1241         struct mlx5_ib_flow_handler *handler_ucast = NULL;
1242         struct mlx5_ib_flow_handler *handler = NULL;
1243
1244         static struct {
1245                 struct ib_flow_attr     flow_attr;
1246                 struct ib_flow_spec_eth eth_flow;
1247         } leftovers_specs[] = {
1248                 [LEFTOVERS_MC] = {
1249                         .flow_attr = {
1250                                 .num_of_specs = 1,
1251                                 .size = sizeof(leftovers_specs[0])
1252                         },
1253                         .eth_flow = {
1254                                 .type = IB_FLOW_SPEC_ETH,
1255                                 .size = sizeof(struct ib_flow_spec_eth),
1256                                 .mask = {.dst_mac = {0x1} },
1257                                 .val =  {.dst_mac = {0x1} }
1258                         }
1259                 },
1260                 [LEFTOVERS_UC] = {
1261                         .flow_attr = {
1262                                 .num_of_specs = 1,
1263                                 .size = sizeof(leftovers_specs[0])
1264                         },
1265                         .eth_flow = {
1266                                 .type = IB_FLOW_SPEC_ETH,
1267                                 .size = sizeof(struct ib_flow_spec_eth),
1268                                 .mask = {.dst_mac = {0x1} },
1269                                 .val = {.dst_mac = {} }
1270                         }
1271                 }
1272         };
1273
1274         handler = create_flow_rule(dev, ft_prio,
1275                                    &leftovers_specs[LEFTOVERS_MC].flow_attr,
1276                                    dst);
1277         if (!IS_ERR(handler) &&
1278             flow_attr->type == IB_FLOW_ATTR_ALL_DEFAULT) {
1279                 handler_ucast = create_flow_rule(dev, ft_prio,
1280                                                  &leftovers_specs[LEFTOVERS_UC].flow_attr,
1281                                                  dst);
1282                 if (IS_ERR(handler_ucast)) {
1283                         mlx5_del_flow_rules(handler->rule);
1284                         ft_prio->refcount--;
1285                         kfree(handler);
1286                         handler = handler_ucast;
1287                 } else {
1288                         list_add(&handler_ucast->list, &handler->list);
1289                 }
1290         }
1291
1292         return handler;
1293 }
1294
1295 static struct mlx5_ib_flow_handler *create_sniffer_rule(struct mlx5_ib_dev *dev,
1296                                                         struct mlx5_ib_flow_prio *ft_rx,
1297                                                         struct mlx5_ib_flow_prio *ft_tx,
1298                                                         struct mlx5_flow_destination *dst)
1299 {
1300         struct mlx5_ib_flow_handler *handler_rx;
1301         struct mlx5_ib_flow_handler *handler_tx;
1302         int err;
1303         static const struct ib_flow_attr flow_attr  = {
1304                 .num_of_specs = 0,
1305                 .type = IB_FLOW_ATTR_SNIFFER,
1306                 .size = sizeof(flow_attr)
1307         };
1308
1309         handler_rx = create_flow_rule(dev, ft_rx, &flow_attr, dst);
1310         if (IS_ERR(handler_rx)) {
1311                 err = PTR_ERR(handler_rx);
1312                 goto err;
1313         }
1314
1315         handler_tx = create_flow_rule(dev, ft_tx, &flow_attr, dst);
1316         if (IS_ERR(handler_tx)) {
1317                 err = PTR_ERR(handler_tx);
1318                 goto err_tx;
1319         }
1320
1321         list_add(&handler_tx->list, &handler_rx->list);
1322
1323         return handler_rx;
1324
1325 err_tx:
1326         mlx5_del_flow_rules(handler_rx->rule);
1327         ft_rx->refcount--;
1328         kfree(handler_rx);
1329 err:
1330         return ERR_PTR(err);
1331 }
1332
1333 static struct ib_flow *mlx5_ib_create_flow(struct ib_qp *qp,
1334                                            struct ib_flow_attr *flow_attr,
1335                                            struct ib_udata *udata)
1336 {
1337         struct mlx5_ib_dev *dev = to_mdev(qp->device);
1338         struct mlx5_ib_qp *mqp = to_mqp(qp);
1339         struct mlx5_ib_flow_handler *handler = NULL;
1340         struct mlx5_flow_destination *dst = NULL;
1341         struct mlx5_ib_flow_prio *ft_prio_tx = NULL;
1342         struct mlx5_ib_flow_prio *ft_prio;
1343         bool is_egress = flow_attr->flags & IB_FLOW_ATTR_FLAGS_EGRESS;
1344         struct mlx5_ib_create_flow *ucmd = NULL, ucmd_hdr;
1345         size_t min_ucmd_sz, required_ucmd_sz;
1346         int err;
1347         int underlay_qpn;
1348
1349         if (udata && udata->inlen) {
1350                 min_ucmd_sz = offsetofend(struct mlx5_ib_create_flow, reserved);
1351                 if (udata->inlen < min_ucmd_sz)
1352                         return ERR_PTR(-EOPNOTSUPP);
1353
1354                 err = ib_copy_from_udata(&ucmd_hdr, udata, min_ucmd_sz);
1355                 if (err)
1356                         return ERR_PTR(err);
1357
1358                 /* currently supports only one counters data */
1359                 if (ucmd_hdr.ncounters_data > 1)
1360                         return ERR_PTR(-EINVAL);
1361
1362                 required_ucmd_sz = min_ucmd_sz +
1363                         sizeof(struct mlx5_ib_flow_counters_data) *
1364                         ucmd_hdr.ncounters_data;
1365                 if (udata->inlen > required_ucmd_sz &&
1366                     !ib_is_udata_cleared(udata, required_ucmd_sz,
1367                                          udata->inlen - required_ucmd_sz))
1368                         return ERR_PTR(-EOPNOTSUPP);
1369
1370                 ucmd = kzalloc(required_ucmd_sz, GFP_KERNEL);
1371                 if (!ucmd)
1372                         return ERR_PTR(-ENOMEM);
1373
1374                 err = ib_copy_from_udata(ucmd, udata, required_ucmd_sz);
1375                 if (err)
1376                         goto free_ucmd;
1377         }
1378
1379         if (flow_attr->priority > MLX5_IB_FLOW_LAST_PRIO) {
1380                 err = -ENOMEM;
1381                 goto free_ucmd;
1382         }
1383
1384         if (flow_attr->flags &
1385             ~(IB_FLOW_ATTR_FLAGS_DONT_TRAP | IB_FLOW_ATTR_FLAGS_EGRESS)) {
1386                 err = -EINVAL;
1387                 goto free_ucmd;
1388         }
1389
1390         if (is_egress &&
1391             (flow_attr->type == IB_FLOW_ATTR_ALL_DEFAULT ||
1392              flow_attr->type == IB_FLOW_ATTR_MC_DEFAULT)) {
1393                 err = -EINVAL;
1394                 goto free_ucmd;
1395         }
1396
1397         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
1398         if (!dst) {
1399                 err = -ENOMEM;
1400                 goto free_ucmd;
1401         }
1402
1403         mutex_lock(&dev->flow_db->lock);
1404
1405         ft_prio = get_flow_table(dev, flow_attr,
1406                                  is_egress ? MLX5_IB_FT_TX : MLX5_IB_FT_RX);
1407         if (IS_ERR(ft_prio)) {
1408                 err = PTR_ERR(ft_prio);
1409                 goto unlock;
1410         }
1411         if (flow_attr->type == IB_FLOW_ATTR_SNIFFER) {
1412                 ft_prio_tx = get_flow_table(dev, flow_attr, MLX5_IB_FT_TX);
1413                 if (IS_ERR(ft_prio_tx)) {
1414                         err = PTR_ERR(ft_prio_tx);
1415                         ft_prio_tx = NULL;
1416                         goto destroy_ft;
1417                 }
1418         }
1419
1420         if (is_egress) {
1421                 dst->type = MLX5_FLOW_DESTINATION_TYPE_PORT;
1422         } else {
1423                 dst->type = MLX5_FLOW_DESTINATION_TYPE_TIR;
1424                 if (mqp->is_rss)
1425                         dst->tir_num = mqp->rss_qp.tirn;
1426                 else
1427                         dst->tir_num = mqp->raw_packet_qp.rq.tirn;
1428         }
1429
1430         switch (flow_attr->type) {
1431         case IB_FLOW_ATTR_NORMAL:
1432                 underlay_qpn = (mqp->flags & IB_QP_CREATE_SOURCE_QPN) ?
1433                                        mqp->underlay_qpn :
1434                                        0;
1435                 handler = _create_flow_rule(dev, ft_prio, flow_attr, dst,
1436                                             underlay_qpn, ucmd);
1437                 break;
1438         case IB_FLOW_ATTR_ALL_DEFAULT:
1439         case IB_FLOW_ATTR_MC_DEFAULT:
1440                 handler = create_leftovers_rule(dev, ft_prio, flow_attr, dst);
1441                 break;
1442         case IB_FLOW_ATTR_SNIFFER:
1443                 handler = create_sniffer_rule(dev, ft_prio, ft_prio_tx, dst);
1444                 break;
1445         default:
1446                 err = -EINVAL;
1447                 goto destroy_ft;
1448         }
1449
1450         if (IS_ERR(handler)) {
1451                 err = PTR_ERR(handler);
1452                 handler = NULL;
1453                 goto destroy_ft;
1454         }
1455
1456         mutex_unlock(&dev->flow_db->lock);
1457         kfree(dst);
1458         kfree(ucmd);
1459
1460         return &handler->ibflow;
1461
1462 destroy_ft:
1463         put_flow_table(dev, ft_prio, false);
1464         if (ft_prio_tx)
1465                 put_flow_table(dev, ft_prio_tx, false);
1466 unlock:
1467         mutex_unlock(&dev->flow_db->lock);
1468         kfree(dst);
1469 free_ucmd:
1470         kfree(ucmd);
1471         return ERR_PTR(err);
1472 }
1473
1474 static struct mlx5_ib_flow_prio *
1475 _get_flow_table(struct mlx5_ib_dev *dev,
1476                 struct mlx5_ib_flow_matcher *fs_matcher,
1477                 bool mcast)
1478 {
1479         struct mlx5_flow_namespace *ns = NULL;
1480         struct mlx5_ib_flow_prio *prio = NULL;
1481         int max_table_size = 0;
1482         bool esw_encap;
1483         u32 flags = 0;
1484         int priority;
1485
1486         if (mcast)
1487                 priority = MLX5_IB_FLOW_MCAST_PRIO;
1488         else
1489                 priority = ib_prio_to_core_prio(fs_matcher->priority, false);
1490
1491         esw_encap = mlx5_eswitch_get_encap_mode(dev->mdev) !=
1492                 DEVLINK_ESWITCH_ENCAP_MODE_NONE;
1493         switch (fs_matcher->ns_type) {
1494         case MLX5_FLOW_NAMESPACE_BYPASS:
1495                 max_table_size = BIT(
1496                         MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev, log_max_ft_size));
1497                 if (MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev, decap) && !esw_encap)
1498                         flags |= MLX5_FLOW_TABLE_TUNNEL_EN_DECAP;
1499                 if (MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev,
1500                                               reformat_l3_tunnel_to_l2) &&
1501                     !esw_encap)
1502                         flags |= MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT;
1503                 break;
1504         case MLX5_FLOW_NAMESPACE_EGRESS:
1505                 max_table_size = BIT(
1506                         MLX5_CAP_FLOWTABLE_NIC_TX(dev->mdev, log_max_ft_size));
1507                 if (MLX5_CAP_FLOWTABLE_NIC_TX(dev->mdev, reformat) &&
1508                     !esw_encap)
1509                         flags |= MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT;
1510                 break;
1511         case MLX5_FLOW_NAMESPACE_FDB_BYPASS:
1512                 max_table_size = BIT(
1513                         MLX5_CAP_ESW_FLOWTABLE_FDB(dev->mdev, log_max_ft_size));
1514                 if (MLX5_CAP_ESW_FLOWTABLE_FDB(dev->mdev, decap) && esw_encap)
1515                         flags |= MLX5_FLOW_TABLE_TUNNEL_EN_DECAP;
1516                 if (MLX5_CAP_ESW_FLOWTABLE_FDB(dev->mdev,
1517                                                reformat_l3_tunnel_to_l2) &&
1518                     esw_encap)
1519                         flags |= MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT;
1520                 priority = fs_matcher->priority;
1521                 break;
1522         case MLX5_FLOW_NAMESPACE_RDMA_RX:
1523                 max_table_size = BIT(
1524                         MLX5_CAP_FLOWTABLE_RDMA_RX(dev->mdev, log_max_ft_size));
1525                 priority = fs_matcher->priority;
1526                 break;
1527         case MLX5_FLOW_NAMESPACE_RDMA_TX:
1528                 max_table_size = BIT(
1529                         MLX5_CAP_FLOWTABLE_RDMA_TX(dev->mdev, log_max_ft_size));
1530                 priority = fs_matcher->priority;
1531                 break;
1532         default:
1533                 break;
1534         }
1535
1536         max_table_size = min_t(int, max_table_size, MLX5_FS_MAX_ENTRIES);
1537
1538         ns = mlx5_get_flow_namespace(dev->mdev, fs_matcher->ns_type);
1539         if (!ns)
1540                 return ERR_PTR(-EOPNOTSUPP);
1541
1542         switch (fs_matcher->ns_type) {
1543         case MLX5_FLOW_NAMESPACE_BYPASS:
1544                 prio = &dev->flow_db->prios[priority];
1545                 break;
1546         case MLX5_FLOW_NAMESPACE_EGRESS:
1547                 prio = &dev->flow_db->egress_prios[priority];
1548                 break;
1549         case MLX5_FLOW_NAMESPACE_FDB_BYPASS:
1550                 prio = &dev->flow_db->fdb[priority];
1551                 break;
1552         case MLX5_FLOW_NAMESPACE_RDMA_RX:
1553                 prio = &dev->flow_db->rdma_rx[priority];
1554                 break;
1555         case MLX5_FLOW_NAMESPACE_RDMA_TX:
1556                 prio = &dev->flow_db->rdma_tx[priority];
1557                 break;
1558         default: return ERR_PTR(-EINVAL);
1559         }
1560
1561         if (!prio)
1562                 return ERR_PTR(-EINVAL);
1563
1564         if (prio->flow_table)
1565                 return prio;
1566
1567         return _get_prio(ns, prio, priority, max_table_size,
1568                          MLX5_FS_MAX_TYPES, flags);
1569 }
1570
1571 static struct mlx5_ib_flow_handler *
1572 _create_raw_flow_rule(struct mlx5_ib_dev *dev,
1573                       struct mlx5_ib_flow_prio *ft_prio,
1574                       struct mlx5_flow_destination *dst,
1575                       struct mlx5_ib_flow_matcher  *fs_matcher,
1576                       struct mlx5_flow_context *flow_context,
1577                       struct mlx5_flow_act *flow_act,
1578                       void *cmd_in, int inlen,
1579                       int dst_num)
1580 {
1581         struct mlx5_ib_flow_handler *handler;
1582         struct mlx5_flow_spec *spec;
1583         struct mlx5_flow_table *ft = ft_prio->flow_table;
1584         int err = 0;
1585
1586         spec = kvzalloc(sizeof(*spec), GFP_KERNEL);
1587         handler = kzalloc(sizeof(*handler), GFP_KERNEL);
1588         if (!handler || !spec) {
1589                 err = -ENOMEM;
1590                 goto free;
1591         }
1592
1593         INIT_LIST_HEAD(&handler->list);
1594
1595         memcpy(spec->match_value, cmd_in, inlen);
1596         memcpy(spec->match_criteria, fs_matcher->matcher_mask.match_params,
1597                fs_matcher->mask_len);
1598         spec->match_criteria_enable = fs_matcher->match_criteria_enable;
1599         spec->flow_context = *flow_context;
1600
1601         handler->rule = mlx5_add_flow_rules(ft, spec,
1602                                             flow_act, dst, dst_num);
1603
1604         if (IS_ERR(handler->rule)) {
1605                 err = PTR_ERR(handler->rule);
1606                 goto free;
1607         }
1608
1609         ft_prio->refcount++;
1610         handler->prio = ft_prio;
1611         handler->dev = dev;
1612         ft_prio->flow_table = ft;
1613
1614 free:
1615         if (err)
1616                 kfree(handler);
1617         kvfree(spec);
1618         return err ? ERR_PTR(err) : handler;
1619 }
1620
1621 static bool raw_fs_is_multicast(struct mlx5_ib_flow_matcher *fs_matcher,
1622                                 void *match_v)
1623 {
1624         void *match_c;
1625         void *match_v_set_lyr_2_4, *match_c_set_lyr_2_4;
1626         void *dmac, *dmac_mask;
1627         void *ipv4, *ipv4_mask;
1628
1629         if (!(fs_matcher->match_criteria_enable &
1630               (1 << MATCH_CRITERIA_ENABLE_OUTER_BIT)))
1631                 return false;
1632
1633         match_c = fs_matcher->matcher_mask.match_params;
1634         match_v_set_lyr_2_4 = MLX5_ADDR_OF(fte_match_param, match_v,
1635                                            outer_headers);
1636         match_c_set_lyr_2_4 = MLX5_ADDR_OF(fte_match_param, match_c,
1637                                            outer_headers);
1638
1639         dmac = MLX5_ADDR_OF(fte_match_set_lyr_2_4, match_v_set_lyr_2_4,
1640                             dmac_47_16);
1641         dmac_mask = MLX5_ADDR_OF(fte_match_set_lyr_2_4, match_c_set_lyr_2_4,
1642                                  dmac_47_16);
1643
1644         if (is_multicast_ether_addr(dmac) &&
1645             is_multicast_ether_addr(dmac_mask))
1646                 return true;
1647
1648         ipv4 = MLX5_ADDR_OF(fte_match_set_lyr_2_4, match_v_set_lyr_2_4,
1649                             dst_ipv4_dst_ipv6.ipv4_layout.ipv4);
1650
1651         ipv4_mask = MLX5_ADDR_OF(fte_match_set_lyr_2_4, match_c_set_lyr_2_4,
1652                                  dst_ipv4_dst_ipv6.ipv4_layout.ipv4);
1653
1654         if (ipv4_is_multicast(*(__be32 *)(ipv4)) &&
1655             ipv4_is_multicast(*(__be32 *)(ipv4_mask)))
1656                 return true;
1657
1658         return false;
1659 }
1660
1661 static struct mlx5_ib_flow_handler *raw_fs_rule_add(
1662         struct mlx5_ib_dev *dev, struct mlx5_ib_flow_matcher *fs_matcher,
1663         struct mlx5_flow_context *flow_context, struct mlx5_flow_act *flow_act,
1664         u32 counter_id, void *cmd_in, int inlen, int dest_id, int dest_type)
1665 {
1666         struct mlx5_flow_destination *dst;
1667         struct mlx5_ib_flow_prio *ft_prio;
1668         struct mlx5_ib_flow_handler *handler;
1669         int dst_num = 0;
1670         bool mcast;
1671         int err;
1672
1673         if (fs_matcher->flow_type != MLX5_IB_FLOW_TYPE_NORMAL)
1674                 return ERR_PTR(-EOPNOTSUPP);
1675
1676         if (fs_matcher->priority > MLX5_IB_FLOW_LAST_PRIO)
1677                 return ERR_PTR(-ENOMEM);
1678
1679         dst = kcalloc(2, sizeof(*dst), GFP_KERNEL);
1680         if (!dst)
1681                 return ERR_PTR(-ENOMEM);
1682
1683         mcast = raw_fs_is_multicast(fs_matcher, cmd_in);
1684         mutex_lock(&dev->flow_db->lock);
1685
1686         ft_prio = _get_flow_table(dev, fs_matcher, mcast);
1687         if (IS_ERR(ft_prio)) {
1688                 err = PTR_ERR(ft_prio);
1689                 goto unlock;
1690         }
1691
1692         switch (dest_type) {
1693         case MLX5_FLOW_DESTINATION_TYPE_TIR:
1694                 dst[dst_num].type = dest_type;
1695                 dst[dst_num++].tir_num = dest_id;
1696                 flow_act->action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
1697                 break;
1698         case MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE:
1699                 dst[dst_num].type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE_NUM;
1700                 dst[dst_num++].ft_num = dest_id;
1701                 flow_act->action |= MLX5_FLOW_CONTEXT_ACTION_FWD_DEST;
1702                 break;
1703         case MLX5_FLOW_DESTINATION_TYPE_PORT:
1704                 dst[dst_num++].type = MLX5_FLOW_DESTINATION_TYPE_PORT;
1705                 flow_act->action |= MLX5_FLOW_CONTEXT_ACTION_ALLOW;
1706                 break;
1707         default:
1708                 break;
1709         }
1710
1711         if (flow_act->action & MLX5_FLOW_CONTEXT_ACTION_COUNT) {
1712                 dst[dst_num].type = MLX5_FLOW_DESTINATION_TYPE_COUNTER;
1713                 dst[dst_num].counter_id = counter_id;
1714                 dst_num++;
1715         }
1716
1717         handler = _create_raw_flow_rule(dev, ft_prio, dst_num ? dst : NULL,
1718                                         fs_matcher, flow_context, flow_act,
1719                                         cmd_in, inlen, dst_num);
1720
1721         if (IS_ERR(handler)) {
1722                 err = PTR_ERR(handler);
1723                 goto destroy_ft;
1724         }
1725
1726         mutex_unlock(&dev->flow_db->lock);
1727         atomic_inc(&fs_matcher->usecnt);
1728         handler->flow_matcher = fs_matcher;
1729
1730         kfree(dst);
1731
1732         return handler;
1733
1734 destroy_ft:
1735         put_flow_table(dev, ft_prio, false);
1736 unlock:
1737         mutex_unlock(&dev->flow_db->lock);
1738         kfree(dst);
1739
1740         return ERR_PTR(err);
1741 }
1742
1743 static u32 mlx5_ib_flow_action_flags_to_accel_xfrm_flags(u32 mlx5_flags)
1744 {
1745         u32 flags = 0;
1746
1747         if (mlx5_flags & MLX5_IB_UAPI_FLOW_ACTION_FLAGS_REQUIRE_METADATA)
1748                 flags |= MLX5_ACCEL_XFRM_FLAG_REQUIRE_METADATA;
1749
1750         return flags;
1751 }
1752
1753 #define MLX5_FLOW_ACTION_ESP_CREATE_LAST_SUPPORTED                             \
1754         MLX5_IB_UAPI_FLOW_ACTION_FLAGS_REQUIRE_METADATA
1755 static struct ib_flow_action *
1756 mlx5_ib_create_flow_action_esp(struct ib_device *device,
1757                                const struct ib_flow_action_attrs_esp *attr,
1758                                struct uverbs_attr_bundle *attrs)
1759 {
1760         struct mlx5_ib_dev *mdev = to_mdev(device);
1761         struct ib_uverbs_flow_action_esp_keymat_aes_gcm *aes_gcm;
1762         struct mlx5_accel_esp_xfrm_attrs accel_attrs = {};
1763         struct mlx5_ib_flow_action *action;
1764         u64 action_flags;
1765         u64 flags;
1766         int err = 0;
1767
1768         err = uverbs_get_flags64(
1769                 &action_flags, attrs, MLX5_IB_ATTR_CREATE_FLOW_ACTION_FLAGS,
1770                 ((MLX5_FLOW_ACTION_ESP_CREATE_LAST_SUPPORTED << 1) - 1));
1771         if (err)
1772                 return ERR_PTR(err);
1773
1774         flags = mlx5_ib_flow_action_flags_to_accel_xfrm_flags(action_flags);
1775
1776         /* We current only support a subset of the standard features. Only a
1777          * keymat of type AES_GCM, with icv_len == 16, iv_algo == SEQ and esn
1778          * (with overlap). Full offload mode isn't supported.
1779          */
1780         if (!attr->keymat || attr->replay || attr->encap ||
1781             attr->spi || attr->seq || attr->tfc_pad ||
1782             attr->hard_limit_pkts ||
1783             (attr->flags & ~(IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED |
1784                              IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ENCRYPT)))
1785                 return ERR_PTR(-EOPNOTSUPP);
1786
1787         if (attr->keymat->protocol !=
1788             IB_UVERBS_FLOW_ACTION_ESP_KEYMAT_AES_GCM)
1789                 return ERR_PTR(-EOPNOTSUPP);
1790
1791         aes_gcm = &attr->keymat->keymat.aes_gcm;
1792
1793         if (aes_gcm->icv_len != 16 ||
1794             aes_gcm->iv_algo != IB_UVERBS_FLOW_ACTION_IV_ALGO_SEQ)
1795                 return ERR_PTR(-EOPNOTSUPP);
1796
1797         action = kmalloc(sizeof(*action), GFP_KERNEL);
1798         if (!action)
1799                 return ERR_PTR(-ENOMEM);
1800
1801         action->esp_aes_gcm.ib_flags = attr->flags;
1802         memcpy(&accel_attrs.keymat.aes_gcm.aes_key, &aes_gcm->aes_key,
1803                sizeof(accel_attrs.keymat.aes_gcm.aes_key));
1804         accel_attrs.keymat.aes_gcm.key_len = aes_gcm->key_len * 8;
1805         memcpy(&accel_attrs.keymat.aes_gcm.salt, &aes_gcm->salt,
1806                sizeof(accel_attrs.keymat.aes_gcm.salt));
1807         memcpy(&accel_attrs.keymat.aes_gcm.seq_iv, &aes_gcm->iv,
1808                sizeof(accel_attrs.keymat.aes_gcm.seq_iv));
1809         accel_attrs.keymat.aes_gcm.icv_len = aes_gcm->icv_len * 8;
1810         accel_attrs.keymat.aes_gcm.iv_algo = MLX5_ACCEL_ESP_AES_GCM_IV_ALGO_SEQ;
1811         accel_attrs.keymat_type = MLX5_ACCEL_ESP_KEYMAT_AES_GCM;
1812
1813         accel_attrs.esn = attr->esn;
1814         if (attr->flags & IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED)
1815                 accel_attrs.flags |= MLX5_ACCEL_ESP_FLAGS_ESN_TRIGGERED;
1816         if (attr->flags & IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW)
1817                 accel_attrs.flags |= MLX5_ACCEL_ESP_FLAGS_ESN_STATE_OVERLAP;
1818
1819         if (attr->flags & IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ENCRYPT)
1820                 accel_attrs.action |= MLX5_ACCEL_ESP_ACTION_ENCRYPT;
1821
1822         action->esp_aes_gcm.ctx =
1823                 mlx5_accel_esp_create_xfrm(mdev->mdev, &accel_attrs, flags);
1824         if (IS_ERR(action->esp_aes_gcm.ctx)) {
1825                 err = PTR_ERR(action->esp_aes_gcm.ctx);
1826                 goto err_parse;
1827         }
1828
1829         action->esp_aes_gcm.ib_flags = attr->flags;
1830
1831         return &action->ib_action;
1832
1833 err_parse:
1834         kfree(action);
1835         return ERR_PTR(err);
1836 }
1837
1838 static int
1839 mlx5_ib_modify_flow_action_esp(struct ib_flow_action *action,
1840                                const struct ib_flow_action_attrs_esp *attr,
1841                                struct uverbs_attr_bundle *attrs)
1842 {
1843         struct mlx5_ib_flow_action *maction = to_mflow_act(action);
1844         struct mlx5_accel_esp_xfrm_attrs accel_attrs;
1845         int err = 0;
1846
1847         if (attr->keymat || attr->replay || attr->encap ||
1848             attr->spi || attr->seq || attr->tfc_pad ||
1849             attr->hard_limit_pkts ||
1850             (attr->flags & ~(IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED |
1851                              IB_FLOW_ACTION_ESP_FLAGS_MOD_ESP_ATTRS |
1852                              IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW)))
1853                 return -EOPNOTSUPP;
1854
1855         /* Only the ESN value or the MLX5_ACCEL_ESP_FLAGS_ESN_STATE_OVERLAP can
1856          * be modified.
1857          */
1858         if (!(maction->esp_aes_gcm.ib_flags &
1859               IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED) &&
1860             attr->flags & (IB_FLOW_ACTION_ESP_FLAGS_ESN_TRIGGERED |
1861                            IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW))
1862                 return -EINVAL;
1863
1864         memcpy(&accel_attrs, &maction->esp_aes_gcm.ctx->attrs,
1865                sizeof(accel_attrs));
1866
1867         accel_attrs.esn = attr->esn;
1868         if (attr->flags & IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW)
1869                 accel_attrs.flags |= MLX5_ACCEL_ESP_FLAGS_ESN_STATE_OVERLAP;
1870         else
1871                 accel_attrs.flags &= ~MLX5_ACCEL_ESP_FLAGS_ESN_STATE_OVERLAP;
1872
1873         err = mlx5_accel_esp_modify_xfrm(maction->esp_aes_gcm.ctx,
1874                                          &accel_attrs);
1875         if (err)
1876                 return err;
1877
1878         maction->esp_aes_gcm.ib_flags &=
1879                 ~IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW;
1880         maction->esp_aes_gcm.ib_flags |=
1881                 attr->flags & IB_UVERBS_FLOW_ACTION_ESP_FLAGS_ESN_NEW_WINDOW;
1882
1883         return 0;
1884 }
1885
1886 static void destroy_flow_action_raw(struct mlx5_ib_flow_action *maction)
1887 {
1888         switch (maction->flow_action_raw.sub_type) {
1889         case MLX5_IB_FLOW_ACTION_MODIFY_HEADER:
1890                 mlx5_modify_header_dealloc(maction->flow_action_raw.dev->mdev,
1891                                            maction->flow_action_raw.modify_hdr);
1892                 break;
1893         case MLX5_IB_FLOW_ACTION_PACKET_REFORMAT:
1894                 mlx5_packet_reformat_dealloc(maction->flow_action_raw.dev->mdev,
1895                                              maction->flow_action_raw.pkt_reformat);
1896                 break;
1897         case MLX5_IB_FLOW_ACTION_DECAP:
1898                 break;
1899         default:
1900                 break;
1901         }
1902 }
1903
1904 static int mlx5_ib_destroy_flow_action(struct ib_flow_action *action)
1905 {
1906         struct mlx5_ib_flow_action *maction = to_mflow_act(action);
1907
1908         switch (action->type) {
1909         case IB_FLOW_ACTION_ESP:
1910                 /*
1911                  * We only support aes_gcm by now, so we implicitly know this is
1912                  * the underline crypto.
1913                  */
1914                 mlx5_accel_esp_destroy_xfrm(maction->esp_aes_gcm.ctx);
1915                 break;
1916         case IB_FLOW_ACTION_UNSPECIFIED:
1917                 destroy_flow_action_raw(maction);
1918                 break;
1919         default:
1920                 WARN_ON(true);
1921                 break;
1922         }
1923
1924         kfree(maction);
1925         return 0;
1926 }
1927
1928 static int
1929 mlx5_ib_ft_type_to_namespace(enum mlx5_ib_uapi_flow_table_type table_type,
1930                              enum mlx5_flow_namespace_type *namespace)
1931 {
1932         switch (table_type) {
1933         case MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_RX:
1934                 *namespace = MLX5_FLOW_NAMESPACE_BYPASS;
1935                 break;
1936         case MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_TX:
1937                 *namespace = MLX5_FLOW_NAMESPACE_EGRESS;
1938                 break;
1939         case MLX5_IB_UAPI_FLOW_TABLE_TYPE_FDB:
1940                 *namespace = MLX5_FLOW_NAMESPACE_FDB_BYPASS;
1941                 break;
1942         case MLX5_IB_UAPI_FLOW_TABLE_TYPE_RDMA_RX:
1943                 *namespace = MLX5_FLOW_NAMESPACE_RDMA_RX;
1944                 break;
1945         case MLX5_IB_UAPI_FLOW_TABLE_TYPE_RDMA_TX:
1946                 *namespace = MLX5_FLOW_NAMESPACE_RDMA_TX;
1947                 break;
1948         default:
1949                 return -EINVAL;
1950         }
1951
1952         return 0;
1953 }
1954
1955 static const struct uverbs_attr_spec mlx5_ib_flow_type[] = {
1956         [MLX5_IB_FLOW_TYPE_NORMAL] = {
1957                 .type = UVERBS_ATTR_TYPE_PTR_IN,
1958                 .u.ptr = {
1959                         .len = sizeof(u16), /* data is priority */
1960                         .min_len = sizeof(u16),
1961                 }
1962         },
1963         [MLX5_IB_FLOW_TYPE_SNIFFER] = {
1964                 .type = UVERBS_ATTR_TYPE_PTR_IN,
1965                 UVERBS_ATTR_NO_DATA(),
1966         },
1967         [MLX5_IB_FLOW_TYPE_ALL_DEFAULT] = {
1968                 .type = UVERBS_ATTR_TYPE_PTR_IN,
1969                 UVERBS_ATTR_NO_DATA(),
1970         },
1971         [MLX5_IB_FLOW_TYPE_MC_DEFAULT] = {
1972                 .type = UVERBS_ATTR_TYPE_PTR_IN,
1973                 UVERBS_ATTR_NO_DATA(),
1974         },
1975 };
1976
1977 static bool is_flow_dest(void *obj, int *dest_id, int *dest_type)
1978 {
1979         struct devx_obj *devx_obj = obj;
1980         u16 opcode = MLX5_GET(general_obj_in_cmd_hdr, devx_obj->dinbox, opcode);
1981
1982         switch (opcode) {
1983         case MLX5_CMD_OP_DESTROY_TIR:
1984                 *dest_type = MLX5_FLOW_DESTINATION_TYPE_TIR;
1985                 *dest_id = MLX5_GET(general_obj_in_cmd_hdr, devx_obj->dinbox,
1986                                     obj_id);
1987                 return true;
1988
1989         case MLX5_CMD_OP_DESTROY_FLOW_TABLE:
1990                 *dest_type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE;
1991                 *dest_id = MLX5_GET(destroy_flow_table_in, devx_obj->dinbox,
1992                                     table_id);
1993                 return true;
1994         default:
1995                 return false;
1996         }
1997 }
1998
1999 static int get_dests(struct uverbs_attr_bundle *attrs,
2000                      struct mlx5_ib_flow_matcher *fs_matcher, int *dest_id,
2001                      int *dest_type, struct ib_qp **qp, u32 *flags)
2002 {
2003         bool dest_devx, dest_qp;
2004         void *devx_obj;
2005         int err;
2006
2007         dest_devx = uverbs_attr_is_valid(attrs,
2008                                          MLX5_IB_ATTR_CREATE_FLOW_DEST_DEVX);
2009         dest_qp = uverbs_attr_is_valid(attrs,
2010                                        MLX5_IB_ATTR_CREATE_FLOW_DEST_QP);
2011
2012         *flags = 0;
2013         err = uverbs_get_flags32(flags, attrs, MLX5_IB_ATTR_CREATE_FLOW_FLAGS,
2014                                  MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DEFAULT_MISS |
2015                                          MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DROP);
2016         if (err)
2017                 return err;
2018
2019         /* Both flags are not allowed */
2020         if (*flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DEFAULT_MISS &&
2021             *flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DROP)
2022                 return -EINVAL;
2023
2024         if (fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_BYPASS) {
2025                 if (dest_devx && (dest_qp || *flags))
2026                         return -EINVAL;
2027                 else if (dest_qp && *flags)
2028                         return -EINVAL;
2029         }
2030
2031         /* Allow only DEVX object, drop as dest for FDB */
2032         if (fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_FDB_BYPASS &&
2033             !(dest_devx || (*flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DROP)))
2034                 return -EINVAL;
2035
2036         /* Allow only DEVX object or QP as dest when inserting to RDMA_RX */
2037         if ((fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_RDMA_RX) &&
2038             ((!dest_devx && !dest_qp) || (dest_devx && dest_qp)))
2039                 return -EINVAL;
2040
2041         *qp = NULL;
2042         if (dest_devx) {
2043                 devx_obj =
2044                         uverbs_attr_get_obj(attrs,
2045                                             MLX5_IB_ATTR_CREATE_FLOW_DEST_DEVX);
2046
2047                 /* Verify that the given DEVX object is a flow
2048                  * steering destination.
2049                  */
2050                 if (!is_flow_dest(devx_obj, dest_id, dest_type))
2051                         return -EINVAL;
2052                 /* Allow only flow table as dest when inserting to FDB or RDMA_RX */
2053                 if ((fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_FDB_BYPASS ||
2054                      fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_RDMA_RX) &&
2055                     *dest_type != MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE)
2056                         return -EINVAL;
2057         } else if (dest_qp) {
2058                 struct mlx5_ib_qp *mqp;
2059
2060                 *qp = uverbs_attr_get_obj(attrs,
2061                                           MLX5_IB_ATTR_CREATE_FLOW_DEST_QP);
2062                 if (IS_ERR(*qp))
2063                         return PTR_ERR(*qp);
2064
2065                 if ((*qp)->qp_type != IB_QPT_RAW_PACKET)
2066                         return -EINVAL;
2067
2068                 mqp = to_mqp(*qp);
2069                 if (mqp->is_rss)
2070                         *dest_id = mqp->rss_qp.tirn;
2071                 else
2072                         *dest_id = mqp->raw_packet_qp.rq.tirn;
2073                 *dest_type = MLX5_FLOW_DESTINATION_TYPE_TIR;
2074         } else if ((fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_EGRESS ||
2075                     fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_RDMA_TX) &&
2076                    !(*flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DROP)) {
2077                 *dest_type = MLX5_FLOW_DESTINATION_TYPE_PORT;
2078         }
2079
2080         if (*dest_type == MLX5_FLOW_DESTINATION_TYPE_TIR &&
2081             (fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_EGRESS ||
2082              fs_matcher->ns_type == MLX5_FLOW_NAMESPACE_RDMA_TX))
2083                 return -EINVAL;
2084
2085         return 0;
2086 }
2087
2088 static bool is_flow_counter(void *obj, u32 offset, u32 *counter_id)
2089 {
2090         struct devx_obj *devx_obj = obj;
2091         u16 opcode = MLX5_GET(general_obj_in_cmd_hdr, devx_obj->dinbox, opcode);
2092
2093         if (opcode == MLX5_CMD_OP_DEALLOC_FLOW_COUNTER) {
2094
2095                 if (offset && offset >= devx_obj->flow_counter_bulk_size)
2096                         return false;
2097
2098                 *counter_id = MLX5_GET(dealloc_flow_counter_in,
2099                                        devx_obj->dinbox,
2100                                        flow_counter_id);
2101                 *counter_id += offset;
2102                 return true;
2103         }
2104
2105         return false;
2106 }
2107
2108 #define MLX5_IB_CREATE_FLOW_MAX_FLOW_ACTIONS 2
2109 static int UVERBS_HANDLER(MLX5_IB_METHOD_CREATE_FLOW)(
2110         struct uverbs_attr_bundle *attrs)
2111 {
2112         struct mlx5_flow_context flow_context = {.flow_tag =
2113                 MLX5_FS_DEFAULT_FLOW_TAG};
2114         u32 *offset_attr, offset = 0, counter_id = 0;
2115         int dest_id, dest_type = -1, inlen, len, ret, i;
2116         struct mlx5_ib_flow_handler *flow_handler;
2117         struct mlx5_ib_flow_matcher *fs_matcher;
2118         struct ib_uobject **arr_flow_actions;
2119         struct ib_uflow_resources *uflow_res;
2120         struct mlx5_flow_act flow_act = {};
2121         struct ib_qp *qp = NULL;
2122         void *devx_obj, *cmd_in;
2123         struct ib_uobject *uobj;
2124         struct mlx5_ib_dev *dev;
2125         u32 flags;
2126
2127         if (!capable(CAP_NET_RAW))
2128                 return -EPERM;
2129
2130         fs_matcher = uverbs_attr_get_obj(attrs,
2131                                          MLX5_IB_ATTR_CREATE_FLOW_MATCHER);
2132         uobj =  uverbs_attr_get_uobject(attrs, MLX5_IB_ATTR_CREATE_FLOW_HANDLE);
2133         dev = mlx5_udata_to_mdev(&attrs->driver_udata);
2134
2135         if (get_dests(attrs, fs_matcher, &dest_id, &dest_type, &qp, &flags))
2136                 return -EINVAL;
2137
2138         if (flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DEFAULT_MISS)
2139                 flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_FWD_NEXT_NS;
2140
2141         if (flags & MLX5_IB_ATTR_CREATE_FLOW_FLAGS_DROP)
2142                 flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_DROP;
2143
2144         len = uverbs_attr_get_uobjs_arr(attrs,
2145                 MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX, &arr_flow_actions);
2146         if (len) {
2147                 devx_obj = arr_flow_actions[0]->object;
2148
2149                 if (uverbs_attr_is_valid(attrs,
2150                                          MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX_OFFSET)) {
2151
2152                         int num_offsets = uverbs_attr_ptr_get_array_size(
2153                                 attrs,
2154                                 MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX_OFFSET,
2155                                 sizeof(u32));
2156
2157                         if (num_offsets != 1)
2158                                 return -EINVAL;
2159
2160                         offset_attr = uverbs_attr_get_alloced_ptr(
2161                                 attrs,
2162                                 MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX_OFFSET);
2163                         offset = *offset_attr;
2164                 }
2165
2166                 if (!is_flow_counter(devx_obj, offset, &counter_id))
2167                         return -EINVAL;
2168
2169                 flow_act.action |= MLX5_FLOW_CONTEXT_ACTION_COUNT;
2170         }
2171
2172         cmd_in = uverbs_attr_get_alloced_ptr(
2173                 attrs, MLX5_IB_ATTR_CREATE_FLOW_MATCH_VALUE);
2174         inlen = uverbs_attr_get_len(attrs,
2175                                     MLX5_IB_ATTR_CREATE_FLOW_MATCH_VALUE);
2176
2177         uflow_res = flow_resources_alloc(MLX5_IB_CREATE_FLOW_MAX_FLOW_ACTIONS);
2178         if (!uflow_res)
2179                 return -ENOMEM;
2180
2181         len = uverbs_attr_get_uobjs_arr(attrs,
2182                 MLX5_IB_ATTR_CREATE_FLOW_ARR_FLOW_ACTIONS, &arr_flow_actions);
2183         for (i = 0; i < len; i++) {
2184                 struct mlx5_ib_flow_action *maction =
2185                         to_mflow_act(arr_flow_actions[i]->object);
2186
2187                 ret = parse_flow_flow_action(maction, false, &flow_act);
2188                 if (ret)
2189                         goto err_out;
2190                 flow_resources_add(uflow_res, IB_FLOW_SPEC_ACTION_HANDLE,
2191                                    arr_flow_actions[i]->object);
2192         }
2193
2194         ret = uverbs_copy_from(&flow_context.flow_tag, attrs,
2195                                MLX5_IB_ATTR_CREATE_FLOW_TAG);
2196         if (!ret) {
2197                 if (flow_context.flow_tag >= BIT(24)) {
2198                         ret = -EINVAL;
2199                         goto err_out;
2200                 }
2201                 flow_context.flags |= FLOW_CONTEXT_HAS_TAG;
2202         }
2203
2204         flow_handler =
2205                 raw_fs_rule_add(dev, fs_matcher, &flow_context, &flow_act,
2206                                 counter_id, cmd_in, inlen, dest_id, dest_type);
2207         if (IS_ERR(flow_handler)) {
2208                 ret = PTR_ERR(flow_handler);
2209                 goto err_out;
2210         }
2211
2212         ib_set_flow(uobj, &flow_handler->ibflow, qp, &dev->ib_dev, uflow_res);
2213
2214         return 0;
2215 err_out:
2216         ib_uverbs_flow_resources_free(uflow_res);
2217         return ret;
2218 }
2219
2220 static int flow_matcher_cleanup(struct ib_uobject *uobject,
2221                                 enum rdma_remove_reason why,
2222                                 struct uverbs_attr_bundle *attrs)
2223 {
2224         struct mlx5_ib_flow_matcher *obj = uobject->object;
2225
2226         if (atomic_read(&obj->usecnt))
2227                 return -EBUSY;
2228
2229         kfree(obj);
2230         return 0;
2231 }
2232
2233 static int mlx5_ib_matcher_ns(struct uverbs_attr_bundle *attrs,
2234                               struct mlx5_ib_flow_matcher *obj)
2235 {
2236         enum mlx5_ib_uapi_flow_table_type ft_type =
2237                 MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_RX;
2238         u32 flags;
2239         int err;
2240
2241         /* New users should use MLX5_IB_ATTR_FLOW_MATCHER_FT_TYPE and older
2242          * users should switch to it. We leave this to not break userspace
2243          */
2244         if (uverbs_attr_is_valid(attrs, MLX5_IB_ATTR_FLOW_MATCHER_FT_TYPE) &&
2245             uverbs_attr_is_valid(attrs, MLX5_IB_ATTR_FLOW_MATCHER_FLOW_FLAGS))
2246                 return -EINVAL;
2247
2248         if (uverbs_attr_is_valid(attrs, MLX5_IB_ATTR_FLOW_MATCHER_FT_TYPE)) {
2249                 err = uverbs_get_const(&ft_type, attrs,
2250                                        MLX5_IB_ATTR_FLOW_MATCHER_FT_TYPE);
2251                 if (err)
2252                         return err;
2253
2254                 err = mlx5_ib_ft_type_to_namespace(ft_type, &obj->ns_type);
2255                 if (err)
2256                         return err;
2257
2258                 return 0;
2259         }
2260
2261         if (uverbs_attr_is_valid(attrs, MLX5_IB_ATTR_FLOW_MATCHER_FLOW_FLAGS)) {
2262                 err = uverbs_get_flags32(&flags, attrs,
2263                                          MLX5_IB_ATTR_FLOW_MATCHER_FLOW_FLAGS,
2264                                          IB_FLOW_ATTR_FLAGS_EGRESS);
2265                 if (err)
2266                         return err;
2267
2268                 if (flags) {
2269                         mlx5_ib_ft_type_to_namespace(
2270                                 MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_TX,
2271                                 &obj->ns_type);
2272                         return 0;
2273                 }
2274         }
2275
2276         obj->ns_type = MLX5_FLOW_NAMESPACE_BYPASS;
2277
2278         return 0;
2279 }
2280
2281 static int UVERBS_HANDLER(MLX5_IB_METHOD_FLOW_MATCHER_CREATE)(
2282         struct uverbs_attr_bundle *attrs)
2283 {
2284         struct ib_uobject *uobj = uverbs_attr_get_uobject(
2285                 attrs, MLX5_IB_ATTR_FLOW_MATCHER_CREATE_HANDLE);
2286         struct mlx5_ib_dev *dev = mlx5_udata_to_mdev(&attrs->driver_udata);
2287         struct mlx5_ib_flow_matcher *obj;
2288         int err;
2289
2290         obj = kzalloc(sizeof(struct mlx5_ib_flow_matcher), GFP_KERNEL);
2291         if (!obj)
2292                 return -ENOMEM;
2293
2294         obj->mask_len = uverbs_attr_get_len(
2295                 attrs, MLX5_IB_ATTR_FLOW_MATCHER_MATCH_MASK);
2296         err = uverbs_copy_from(&obj->matcher_mask,
2297                                attrs,
2298                                MLX5_IB_ATTR_FLOW_MATCHER_MATCH_MASK);
2299         if (err)
2300                 goto end;
2301
2302         obj->flow_type = uverbs_attr_get_enum_id(
2303                 attrs, MLX5_IB_ATTR_FLOW_MATCHER_FLOW_TYPE);
2304
2305         if (obj->flow_type == MLX5_IB_FLOW_TYPE_NORMAL) {
2306                 err = uverbs_copy_from(&obj->priority,
2307                                        attrs,
2308                                        MLX5_IB_ATTR_FLOW_MATCHER_FLOW_TYPE);
2309                 if (err)
2310                         goto end;
2311         }
2312
2313         err = uverbs_copy_from(&obj->match_criteria_enable,
2314                                attrs,
2315                                MLX5_IB_ATTR_FLOW_MATCHER_MATCH_CRITERIA);
2316         if (err)
2317                 goto end;
2318
2319         err = mlx5_ib_matcher_ns(attrs, obj);
2320         if (err)
2321                 goto end;
2322
2323         if (obj->ns_type == MLX5_FLOW_NAMESPACE_FDB_BYPASS &&
2324             mlx5_eswitch_mode(dev->mdev) != MLX5_ESWITCH_OFFLOADS) {
2325                 err = -EINVAL;
2326                 goto end;
2327         }
2328
2329         uobj->object = obj;
2330         obj->mdev = dev->mdev;
2331         atomic_set(&obj->usecnt, 0);
2332         return 0;
2333
2334 end:
2335         kfree(obj);
2336         return err;
2337 }
2338
2339 static struct ib_flow_action *
2340 mlx5_ib_create_modify_header(struct mlx5_ib_dev *dev,
2341                              enum mlx5_ib_uapi_flow_table_type ft_type,
2342                              u8 num_actions, void *in)
2343 {
2344         enum mlx5_flow_namespace_type namespace;
2345         struct mlx5_ib_flow_action *maction;
2346         int ret;
2347
2348         ret = mlx5_ib_ft_type_to_namespace(ft_type, &namespace);
2349         if (ret)
2350                 return ERR_PTR(-EINVAL);
2351
2352         maction = kzalloc(sizeof(*maction), GFP_KERNEL);
2353         if (!maction)
2354                 return ERR_PTR(-ENOMEM);
2355
2356         maction->flow_action_raw.modify_hdr =
2357                 mlx5_modify_header_alloc(dev->mdev, namespace, num_actions, in);
2358
2359         if (IS_ERR(maction->flow_action_raw.modify_hdr)) {
2360                 ret = PTR_ERR(maction->flow_action_raw.modify_hdr);
2361                 kfree(maction);
2362                 return ERR_PTR(ret);
2363         }
2364         maction->flow_action_raw.sub_type =
2365                 MLX5_IB_FLOW_ACTION_MODIFY_HEADER;
2366         maction->flow_action_raw.dev = dev;
2367
2368         return &maction->ib_action;
2369 }
2370
2371 static bool mlx5_ib_modify_header_supported(struct mlx5_ib_dev *dev)
2372 {
2373         return MLX5_CAP_FLOWTABLE_NIC_RX(dev->mdev,
2374                                          max_modify_header_actions) ||
2375                MLX5_CAP_FLOWTABLE_NIC_TX(dev->mdev,
2376                                          max_modify_header_actions) ||
2377                MLX5_CAP_FLOWTABLE_RDMA_TX(dev->mdev,
2378                                          max_modify_header_actions);
2379 }
2380
2381 static int UVERBS_HANDLER(MLX5_IB_METHOD_FLOW_ACTION_CREATE_MODIFY_HEADER)(
2382         struct uverbs_attr_bundle *attrs)
2383 {
2384         struct ib_uobject *uobj = uverbs_attr_get_uobject(
2385                 attrs, MLX5_IB_ATTR_CREATE_MODIFY_HEADER_HANDLE);
2386         struct mlx5_ib_dev *mdev = mlx5_udata_to_mdev(&attrs->driver_udata);
2387         enum mlx5_ib_uapi_flow_table_type ft_type;
2388         struct ib_flow_action *action;
2389         int num_actions;
2390         void *in;
2391         int ret;
2392
2393         if (!mlx5_ib_modify_header_supported(mdev))
2394                 return -EOPNOTSUPP;
2395
2396         in = uverbs_attr_get_alloced_ptr(attrs,
2397                 MLX5_IB_ATTR_CREATE_MODIFY_HEADER_ACTIONS_PRM);
2398
2399         num_actions = uverbs_attr_ptr_get_array_size(
2400                 attrs, MLX5_IB_ATTR_CREATE_MODIFY_HEADER_ACTIONS_PRM,
2401                 MLX5_UN_SZ_BYTES(set_add_copy_action_in_auto));
2402         if (num_actions < 0)
2403                 return num_actions;
2404
2405         ret = uverbs_get_const(&ft_type, attrs,
2406                                MLX5_IB_ATTR_CREATE_MODIFY_HEADER_FT_TYPE);
2407         if (ret)
2408                 return ret;
2409         action = mlx5_ib_create_modify_header(mdev, ft_type, num_actions, in);
2410         if (IS_ERR(action))
2411                 return PTR_ERR(action);
2412
2413         uverbs_flow_action_fill_action(action, uobj, &mdev->ib_dev,
2414                                        IB_FLOW_ACTION_UNSPECIFIED);
2415
2416         return 0;
2417 }
2418
2419 static bool mlx5_ib_flow_action_packet_reformat_valid(struct mlx5_ib_dev *ibdev,
2420                                                       u8 packet_reformat_type,
2421                                                       u8 ft_type)
2422 {
2423         switch (packet_reformat_type) {
2424         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TO_L2_TUNNEL:
2425                 if (ft_type == MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_TX)
2426                         return MLX5_CAP_FLOWTABLE(ibdev->mdev,
2427                                                   encap_general_header);
2428                 break;
2429         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TO_L3_TUNNEL:
2430                 if (ft_type == MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_TX)
2431                         return MLX5_CAP_FLOWTABLE_NIC_TX(ibdev->mdev,
2432                                 reformat_l2_to_l3_tunnel);
2433                 break;
2434         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L3_TUNNEL_TO_L2:
2435                 if (ft_type == MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_RX)
2436                         return MLX5_CAP_FLOWTABLE_NIC_RX(ibdev->mdev,
2437                                 reformat_l3_tunnel_to_l2);
2438                 break;
2439         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TUNNEL_TO_L2:
2440                 if (ft_type == MLX5_IB_UAPI_FLOW_TABLE_TYPE_NIC_RX)
2441                         return MLX5_CAP_FLOWTABLE_NIC_RX(ibdev->mdev, decap);
2442                 break;
2443         default:
2444                 break;
2445         }
2446
2447         return false;
2448 }
2449
2450 static int mlx5_ib_dv_to_prm_packet_reforamt_type(u8 dv_prt, u8 *prm_prt)
2451 {
2452         switch (dv_prt) {
2453         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TO_L2_TUNNEL:
2454                 *prm_prt = MLX5_REFORMAT_TYPE_L2_TO_L2_TUNNEL;
2455                 break;
2456         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L3_TUNNEL_TO_L2:
2457                 *prm_prt = MLX5_REFORMAT_TYPE_L3_TUNNEL_TO_L2;
2458                 break;
2459         case MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TO_L3_TUNNEL:
2460                 *prm_prt = MLX5_REFORMAT_TYPE_L2_TO_L3_TUNNEL;
2461                 break;
2462         default:
2463                 return -EINVAL;
2464         }
2465
2466         return 0;
2467 }
2468
2469 static int mlx5_ib_flow_action_create_packet_reformat_ctx(
2470         struct mlx5_ib_dev *dev,
2471         struct mlx5_ib_flow_action *maction,
2472         u8 ft_type, u8 dv_prt,
2473         void *in, size_t len)
2474 {
2475         struct mlx5_pkt_reformat_params reformat_params;
2476         enum mlx5_flow_namespace_type namespace;
2477         u8 prm_prt;
2478         int ret;
2479
2480         ret = mlx5_ib_ft_type_to_namespace(ft_type, &namespace);
2481         if (ret)
2482                 return ret;
2483
2484         ret = mlx5_ib_dv_to_prm_packet_reforamt_type(dv_prt, &prm_prt);
2485         if (ret)
2486                 return ret;
2487
2488         memset(&reformat_params, 0, sizeof(reformat_params));
2489         reformat_params.type = prm_prt;
2490         reformat_params.size = len;
2491         reformat_params.data = in;
2492         maction->flow_action_raw.pkt_reformat =
2493                 mlx5_packet_reformat_alloc(dev->mdev, &reformat_params,
2494                                            namespace);
2495         if (IS_ERR(maction->flow_action_raw.pkt_reformat)) {
2496                 ret = PTR_ERR(maction->flow_action_raw.pkt_reformat);
2497                 return ret;
2498         }
2499
2500         maction->flow_action_raw.sub_type =
2501                 MLX5_IB_FLOW_ACTION_PACKET_REFORMAT;
2502         maction->flow_action_raw.dev = dev;
2503
2504         return 0;
2505 }
2506
2507 static int UVERBS_HANDLER(MLX5_IB_METHOD_FLOW_ACTION_CREATE_PACKET_REFORMAT)(
2508         struct uverbs_attr_bundle *attrs)
2509 {
2510         struct ib_uobject *uobj = uverbs_attr_get_uobject(attrs,
2511                 MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_HANDLE);
2512         struct mlx5_ib_dev *mdev = mlx5_udata_to_mdev(&attrs->driver_udata);
2513         enum mlx5_ib_uapi_flow_action_packet_reformat_type dv_prt;
2514         enum mlx5_ib_uapi_flow_table_type ft_type;
2515         struct mlx5_ib_flow_action *maction;
2516         int ret;
2517
2518         ret = uverbs_get_const(&ft_type, attrs,
2519                                MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_FT_TYPE);
2520         if (ret)
2521                 return ret;
2522
2523         ret = uverbs_get_const(&dv_prt, attrs,
2524                                MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_TYPE);
2525         if (ret)
2526                 return ret;
2527
2528         if (!mlx5_ib_flow_action_packet_reformat_valid(mdev, dv_prt, ft_type))
2529                 return -EOPNOTSUPP;
2530
2531         maction = kzalloc(sizeof(*maction), GFP_KERNEL);
2532         if (!maction)
2533                 return -ENOMEM;
2534
2535         if (dv_prt ==
2536             MLX5_IB_UAPI_FLOW_ACTION_PACKET_REFORMAT_TYPE_L2_TUNNEL_TO_L2) {
2537                 maction->flow_action_raw.sub_type =
2538                         MLX5_IB_FLOW_ACTION_DECAP;
2539                 maction->flow_action_raw.dev = mdev;
2540         } else {
2541                 void *in;
2542                 int len;
2543
2544                 in = uverbs_attr_get_alloced_ptr(attrs,
2545                         MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_DATA_BUF);
2546                 if (IS_ERR(in)) {
2547                         ret = PTR_ERR(in);
2548                         goto free_maction;
2549                 }
2550
2551                 len = uverbs_attr_get_len(attrs,
2552                         MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_DATA_BUF);
2553
2554                 ret = mlx5_ib_flow_action_create_packet_reformat_ctx(mdev,
2555                         maction, ft_type, dv_prt, in, len);
2556                 if (ret)
2557                         goto free_maction;
2558         }
2559
2560         uverbs_flow_action_fill_action(&maction->ib_action, uobj, &mdev->ib_dev,
2561                                        IB_FLOW_ACTION_UNSPECIFIED);
2562         return 0;
2563
2564 free_maction:
2565         kfree(maction);
2566         return ret;
2567 }
2568
2569 DECLARE_UVERBS_NAMED_METHOD(
2570         MLX5_IB_METHOD_CREATE_FLOW,
2571         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_FLOW_HANDLE,
2572                         UVERBS_OBJECT_FLOW,
2573                         UVERBS_ACCESS_NEW,
2574                         UA_MANDATORY),
2575         UVERBS_ATTR_PTR_IN(
2576                 MLX5_IB_ATTR_CREATE_FLOW_MATCH_VALUE,
2577                 UVERBS_ATTR_SIZE(1, sizeof(struct mlx5_ib_match_params)),
2578                 UA_MANDATORY,
2579                 UA_ALLOC_AND_COPY),
2580         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_FLOW_MATCHER,
2581                         MLX5_IB_OBJECT_FLOW_MATCHER,
2582                         UVERBS_ACCESS_READ,
2583                         UA_MANDATORY),
2584         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_FLOW_DEST_QP,
2585                         UVERBS_OBJECT_QP,
2586                         UVERBS_ACCESS_READ),
2587         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_FLOW_DEST_DEVX,
2588                         MLX5_IB_OBJECT_DEVX_OBJ,
2589                         UVERBS_ACCESS_READ),
2590         UVERBS_ATTR_IDRS_ARR(MLX5_IB_ATTR_CREATE_FLOW_ARR_FLOW_ACTIONS,
2591                              UVERBS_OBJECT_FLOW_ACTION,
2592                              UVERBS_ACCESS_READ, 1,
2593                              MLX5_IB_CREATE_FLOW_MAX_FLOW_ACTIONS,
2594                              UA_OPTIONAL),
2595         UVERBS_ATTR_PTR_IN(MLX5_IB_ATTR_CREATE_FLOW_TAG,
2596                            UVERBS_ATTR_TYPE(u32),
2597                            UA_OPTIONAL),
2598         UVERBS_ATTR_IDRS_ARR(MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX,
2599                              MLX5_IB_OBJECT_DEVX_OBJ,
2600                              UVERBS_ACCESS_READ, 1, 1,
2601                              UA_OPTIONAL),
2602         UVERBS_ATTR_PTR_IN(MLX5_IB_ATTR_CREATE_FLOW_ARR_COUNTERS_DEVX_OFFSET,
2603                            UVERBS_ATTR_MIN_SIZE(sizeof(u32)),
2604                            UA_OPTIONAL,
2605                            UA_ALLOC_AND_COPY),
2606         UVERBS_ATTR_FLAGS_IN(MLX5_IB_ATTR_CREATE_FLOW_FLAGS,
2607                              enum mlx5_ib_create_flow_flags,
2608                              UA_OPTIONAL));
2609
2610 DECLARE_UVERBS_NAMED_METHOD_DESTROY(
2611         MLX5_IB_METHOD_DESTROY_FLOW,
2612         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_FLOW_HANDLE,
2613                         UVERBS_OBJECT_FLOW,
2614                         UVERBS_ACCESS_DESTROY,
2615                         UA_MANDATORY));
2616
2617 ADD_UVERBS_METHODS(mlx5_ib_fs,
2618                    UVERBS_OBJECT_FLOW,
2619                    &UVERBS_METHOD(MLX5_IB_METHOD_CREATE_FLOW),
2620                    &UVERBS_METHOD(MLX5_IB_METHOD_DESTROY_FLOW));
2621
2622 DECLARE_UVERBS_NAMED_METHOD(
2623         MLX5_IB_METHOD_FLOW_ACTION_CREATE_MODIFY_HEADER,
2624         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_MODIFY_HEADER_HANDLE,
2625                         UVERBS_OBJECT_FLOW_ACTION,
2626                         UVERBS_ACCESS_NEW,
2627                         UA_MANDATORY),
2628         UVERBS_ATTR_PTR_IN(MLX5_IB_ATTR_CREATE_MODIFY_HEADER_ACTIONS_PRM,
2629                            UVERBS_ATTR_MIN_SIZE(MLX5_UN_SZ_BYTES(
2630                                    set_add_copy_action_in_auto)),
2631                            UA_MANDATORY,
2632                            UA_ALLOC_AND_COPY),
2633         UVERBS_ATTR_CONST_IN(MLX5_IB_ATTR_CREATE_MODIFY_HEADER_FT_TYPE,
2634                              enum mlx5_ib_uapi_flow_table_type,
2635                              UA_MANDATORY));
2636
2637 DECLARE_UVERBS_NAMED_METHOD(
2638         MLX5_IB_METHOD_FLOW_ACTION_CREATE_PACKET_REFORMAT,
2639         UVERBS_ATTR_IDR(MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_HANDLE,
2640                         UVERBS_OBJECT_FLOW_ACTION,
2641                         UVERBS_ACCESS_NEW,
2642                         UA_MANDATORY),
2643         UVERBS_ATTR_PTR_IN(MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_DATA_BUF,
2644                            UVERBS_ATTR_MIN_SIZE(1),
2645                            UA_ALLOC_AND_COPY,
2646                            UA_OPTIONAL),
2647         UVERBS_ATTR_CONST_IN(MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_TYPE,
2648                              enum mlx5_ib_uapi_flow_action_packet_reformat_type,
2649                              UA_MANDATORY),
2650         UVERBS_ATTR_CONST_IN(MLX5_IB_ATTR_CREATE_PACKET_REFORMAT_FT_TYPE,
2651                              enum mlx5_ib_uapi_flow_table_type,
2652                              UA_MANDATORY));
2653
2654 ADD_UVERBS_METHODS(
2655         mlx5_ib_flow_actions,
2656         UVERBS_OBJECT_FLOW_ACTION,
2657         &UVERBS_METHOD(MLX5_IB_METHOD_FLOW_ACTION_CREATE_MODIFY_HEADER),
2658         &UVERBS_METHOD(MLX5_IB_METHOD_FLOW_ACTION_CREATE_PACKET_REFORMAT));
2659
2660 DECLARE_UVERBS_NAMED_METHOD(
2661         MLX5_IB_METHOD_FLOW_MATCHER_CREATE,
2662         UVERBS_ATTR_IDR(MLX5_IB_ATTR_FLOW_MATCHER_CREATE_HANDLE,
2663                         MLX5_IB_OBJECT_FLOW_MATCHER,
2664                         UVERBS_ACCESS_NEW,
2665                         UA_MANDATORY),
2666         UVERBS_ATTR_PTR_IN(
2667                 MLX5_IB_ATTR_FLOW_MATCHER_MATCH_MASK,
2668                 UVERBS_ATTR_SIZE(1, sizeof(struct mlx5_ib_match_params)),
2669                 UA_MANDATORY),
2670         UVERBS_ATTR_ENUM_IN(MLX5_IB_ATTR_FLOW_MATCHER_FLOW_TYPE,
2671                             mlx5_ib_flow_type,
2672                             UA_MANDATORY),
2673         UVERBS_ATTR_PTR_IN(MLX5_IB_ATTR_FLOW_MATCHER_MATCH_CRITERIA,
2674                            UVERBS_ATTR_TYPE(u8),
2675                            UA_MANDATORY),
2676         UVERBS_ATTR_FLAGS_IN(MLX5_IB_ATTR_FLOW_MATCHER_FLOW_FLAGS,
2677                              enum ib_flow_flags,
2678                              UA_OPTIONAL),
2679         UVERBS_ATTR_CONST_IN(MLX5_IB_ATTR_FLOW_MATCHER_FT_TYPE,
2680                              enum mlx5_ib_uapi_flow_table_type,
2681                              UA_OPTIONAL));
2682
2683 DECLARE_UVERBS_NAMED_METHOD_DESTROY(
2684         MLX5_IB_METHOD_FLOW_MATCHER_DESTROY,
2685         UVERBS_ATTR_IDR(MLX5_IB_ATTR_FLOW_MATCHER_DESTROY_HANDLE,
2686                         MLX5_IB_OBJECT_FLOW_MATCHER,
2687                         UVERBS_ACCESS_DESTROY,
2688                         UA_MANDATORY));
2689
2690 DECLARE_UVERBS_NAMED_OBJECT(MLX5_IB_OBJECT_FLOW_MATCHER,
2691                             UVERBS_TYPE_ALLOC_IDR(flow_matcher_cleanup),
2692                             &UVERBS_METHOD(MLX5_IB_METHOD_FLOW_MATCHER_CREATE),
2693                             &UVERBS_METHOD(MLX5_IB_METHOD_FLOW_MATCHER_DESTROY));
2694
2695 const struct uapi_definition mlx5_ib_flow_defs[] = {
2696         UAPI_DEF_CHAIN_OBJ_TREE_NAMED(
2697                 MLX5_IB_OBJECT_FLOW_MATCHER),
2698         UAPI_DEF_CHAIN_OBJ_TREE(
2699                 UVERBS_OBJECT_FLOW,
2700                 &mlx5_ib_fs),
2701         UAPI_DEF_CHAIN_OBJ_TREE(UVERBS_OBJECT_FLOW_ACTION,
2702                                 &mlx5_ib_flow_actions),
2703         {},
2704 };
2705
2706 static const struct ib_device_ops flow_ops = {
2707         .create_flow = mlx5_ib_create_flow,
2708         .destroy_flow = mlx5_ib_destroy_flow,
2709         .destroy_flow_action = mlx5_ib_destroy_flow_action,
2710 };
2711
2712 static const struct ib_device_ops flow_ipsec_ops = {
2713         .create_flow_action_esp = mlx5_ib_create_flow_action_esp,
2714         .modify_flow_action_esp = mlx5_ib_modify_flow_action_esp,
2715 };
2716
2717 int mlx5_ib_fs_init(struct mlx5_ib_dev *dev)
2718 {
2719         dev->flow_db = kzalloc(sizeof(*dev->flow_db), GFP_KERNEL);
2720
2721         if (!dev->flow_db)
2722                 return -ENOMEM;
2723
2724         mutex_init(&dev->flow_db->lock);
2725
2726         ib_set_device_ops(&dev->ib_dev, &flow_ops);
2727         if (mlx5_accel_ipsec_device_caps(dev->mdev) &
2728             MLX5_ACCEL_IPSEC_CAP_DEVICE)
2729                 ib_set_device_ops(&dev->ib_dev, &flow_ipsec_ops);
2730
2731         return 0;
2732 }