drivers/net/mlx5/linux/mlx5_flow_os.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2020 Mellanox Technologies, Ltd
   3  */
   4
   5 #ifndef RTE_PMD_MLX5_FLOW_OS_H_
   6 #define RTE_PMD_MLX5_FLOW_OS_H_
   7
   8 #include "mlx5_flow.h"
   9
  10 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
  11 extern const struct mlx5_flow_driver_ops mlx5_flow_dv_drv_ops;
  12 #endif
  13
  14 /**
  15  * Get OS enforced flow type. MLX5_FLOW_TYPE_MAX means "non enforced type".
  16  *
  17  * @return
  18  *   Flow type (MLX5_FLOW_TYPE_MAX)
  19  */
  20 static inline enum mlx5_flow_drv_type
  21 mlx5_flow_os_get_type(void)
  22 {
  23         return MLX5_FLOW_TYPE_MAX;
  24 }
  25
  26 /**
  27  * Check if item type is supported.
  28  *
  29  * @param item
  30  *   Item type to check.
  31  *
  32  * @return
  33  *   True is this item type is supported, false if not supported.
  34  */
  35 static inline bool
  36 mlx5_flow_os_item_supported(int item __rte_unused)
  37 {
  38         return true;
  39 }
  40
  41 /**
  42  * Check if action type is supported.
  43  *
  44  * @param action
  45  *   Action type to check.
  46  *
  47  * @return
  48  *   True is this action type is supported, false if not supported.
  49  */
  50 static inline bool
  51 mlx5_flow_os_action_supported(int action __rte_unused)
  52 {
  53         return true;
  54 }
  55
  56 /**
  57  * Create flow rule.
  58  *
  59  * @param[in] matcher
  60  *   Pointer to match mask structure.
  61  * @param[in] match_value
  62  *   Pointer to match value structure.
  63  * @param[in] num_actions
  64  *   Number of actions in flow rule.
  65  * @param[in] actions
  66  *   Pointer to array of flow rule actions.
  67  * @param[out] flow
  68  *   Pointer to a valid flow rule object on success, NULL otherwise.
  69  *
  70  * @return
  71  *   0 on success, or -1 on failure and errno is set.
  72  */
  73 static inline int
  74 mlx5_flow_os_create_flow(void *matcher, void *match_value,
  75                          size_t num_actions, void *actions[], void **flow)
  76 {
  77         *flow = mlx5_glue->dv_create_flow(matcher, match_value,
  78                                           num_actions, actions);
  79         return (*flow) ? 0 : -1;
  80 }
  81
  82 /**
  83  * Destroy flow rule.
  84  *
  85  * @param[in] drv_flow_ptr
  86  *   Pointer to flow rule object.
  87  *
  88  * @return
  89  *   0 on success, or the value of errno on failure.
  90  */
  91 static inline int
  92 mlx5_flow_os_destroy_flow(void *drv_flow_ptr)
  93 {
  94         return mlx5_glue->dv_destroy_flow(drv_flow_ptr);
  95 }
  96
  97 /**
  98  * Create flow table.
  99  *
 100  * @param[in] domain
 101  *   Pointer to relevant domain.
 102  * @param[in] table_id
 103  *   Table ID.
 104  * @param[out] table
 105  *   Pointer to a valid flow table object on success, NULL otherwise.
 106  *
 107  * @return
 108  *   0 on success, or -1 on failure and errno is set.
 109  */
 110 static inline int
 111 mlx5_flow_os_create_flow_tbl(void *domain, uint32_t table_id, void **table)
 112 {
 113         *table = mlx5_glue->dr_create_flow_tbl(domain, table_id);
 114         return (*table) ? 0 : -1;
 115 }
 116
 117 /**
 118  * Destroy flow table.
 119  *
 120  * @param[in] table
 121  *   Pointer to table object to destroy.
 122  *
 123  * @return
 124  *   0 on success, or the value of errno on failure.
 125  */
 126 static inline int
 127 mlx5_flow_os_destroy_flow_tbl(void *table)
 128 {
 129         return mlx5_glue->dr_destroy_flow_tbl(table);
 130 }
 131
 132 /**
 133  * Create flow matcher in a flow table.
 134  *
 135  * @param[in] ctx
 136  *   Pointer to relevant device context.
 137  * @param[in] attr
 138  *   Pointer to relevant attributes.
 139  * @param[in] table
 140  *   Pointer to table object.
 141  * @param[out] matcher
 142  *   Pointer to a valid flow matcher object on success, NULL otherwise.
 143  *
 144  * @return
 145  *   0 on success, or -1 on failure and errno is set.
 146  */
 147 static inline int
 148 mlx5_flow_os_create_flow_matcher(void *ctx, void *attr, void *table,
 149                                  void **matcher)
 150 {
 151         *matcher = mlx5_glue->dv_create_flow_matcher(ctx, attr, table);
 152         return (*matcher) ? 0 : -1;
 153 }
 154
 155 /**
 156  * Destroy flow matcher.
 157  *
 158  * @param[in] matcher
 159  *   Pointer to matcher object to destroy.
 160  *
 161  * @return
 162  *   0 on success, or the value of errno on failure.
 163  */
 164 static inline int
 165 mlx5_flow_os_destroy_flow_matcher(void *matcher)
 166 {
 167         return mlx5_glue->dv_destroy_flow_matcher(matcher);
 168 }
 169
 170 /**
 171  * Create flow action: packet reformat.
 172  *
 173  * @param[in] ctx
 174  *   Pointer to relevant device context.
 175  * @param[in] domain
 176  *   Pointer to domain handler.
 177  * @param[in] resource
 178  *   Pointer to action data resource.
 179  * @param[out] action
 180  *   Pointer to a valid action on success, NULL otherwise.
 181  *
 182  *
 183  * @return
 184  *   0 on success, or -1 on failure and errno is set.
 185  */
 186 static inline int
 187 mlx5_flow_os_create_flow_action_packet_reformat(void *ctx, void *domain,
 188                                                 void *resource, void **action)
 189 {
 190         struct mlx5_flow_dv_encap_decap_resource *res =
 191                         (struct mlx5_flow_dv_encap_decap_resource *)resource;
 192
 193         *action = mlx5_glue->dv_create_flow_action_packet_reformat
 194                                         (ctx, res->reformat_type, res->ft_type,
 195                                          domain, res->flags, res->size,
 196                                          (res->size ? res->buf : NULL));
 197         return (*action) ? 0 : -1;
 198 }
 199
 200 /**
 201  * Create flow action: modify header.
 202  *
 203  * @param[in] ctx
 204  *   Pointer to relevant device context.
 205  * @param[in] domain
 206  *   Pointer to domain handler.
 207  * @param[in] resource
 208  *   Pointer to action data resource.
 209  * @param[in] actions_len
 210  *   Total length of actions data in resource.
 211  * @param[out] action
 212  *   Pointer to a valid action on success, NULL otherwise.
 213  *
 214  *
 215  * @return
 216  *   0 on success, or -1 on failure and errno is set.
 217  */
 218 static inline int
 219 mlx5_flow_os_create_flow_action_modify_header(void *ctx, void *domain,
 220                                               void *resource,
 221                                               uint32_t actions_len,
 222                                               void **action)
 223 {
 224         struct mlx5_flow_dv_modify_hdr_resource *res =
 225                         (struct mlx5_flow_dv_modify_hdr_resource *)resource;
 226
 227         *action = mlx5_glue->dv_create_flow_action_modify_header
 228                                         (ctx, res->ft_type, domain, res->root ?
 229                                          MLX5DV_DR_ACTION_FLAGS_ROOT_LEVEL : 0,
 230                                          actions_len, (uint64_t *)res->actions);
 231         return (*action) ? 0 : -1;
 232 }
 233
 234 /**
 235  * Create flow action: destination flow table.
 236  *
 237  * @param[in] tbl_obj
 238  *   Pointer to destination table object.
 239  * @param[out] action
 240  *   Pointer to a valid action on success, NULL otherwise.
 241  *
 242  * @return
 243  *   0 on success, or -1 on failure and errno is set.
 244  */
 245 static inline int
 246 mlx5_flow_os_create_flow_action_dest_flow_tbl(void *tbl_obj, void **action)
 247 {
 248         *action = mlx5_glue->dr_create_flow_action_dest_flow_tbl(tbl_obj);
 249         return (*action) ? 0 : -1;
 250 }
 251
 252 /**
 253  * Create flow action: destination port.
 254  *
 255  * @param[in] domain
 256  *   Pointer to domain handler.
 257  * @param[in] port_id
 258  *   Destination port ID.
 259  * @param[out] action
 260  *   Pointer to a valid action on success, NULL otherwise.
 261  *
 262  * @return
 263  *   0 on success, or -1 on failure and errno is set.
 264  */
 265 static inline int
 266 mlx5_flow_os_create_flow_action_dest_port(void *domain, uint32_t port_id,
 267                                           void **action)
 268 {
 269         /*
 270          * Depending on rdma_core version the glue routine calls
 271          * either mlx5dv_dr_action_create_dest_ib_port(domain, dev_port)
 272          * or mlx5dv_dr_action_create_dest_vport(domain, vport_id).
 273          */
 274         *action = mlx5_glue->dr_create_flow_action_dest_port(domain, port_id);
 275         return (*action) ? 0 : -1;
 276 }
 277
 278 /**
 279  * Create flow action: push vlan.
 280  *
 281  * @param[in] domain
 282  *   Pointer to domain handler.
 283  * @param[in] vlan_tag
 284  *   VLAN tag value.
 285  * @param[out] action
 286  *   Pointer to a valid action on success, NULL otherwise.
 287  *
 288  * @return
 289  *   0 on success, or -1 on failure and errno is set.
 290  */
 291 static inline int
 292 mlx5_flow_os_create_flow_action_push_vlan(void *domain, rte_be32_t vlan_tag,
 293                                           void **action)
 294 {
 295         *action = mlx5_glue->dr_create_flow_action_push_vlan(domain, vlan_tag);
 296         return (*action) ? 0 : -1;
 297 }
 298
 299 /**
 300  * Create flow action: count.
 301  *
 302  * @param[in] cnt_obj
 303  *   Pointer to DevX counter object.
 304  * @param[in] offset
 305  *   Offset of counter in array.
 306  * @param[out] action
 307  *   Pointer to a valid action on success, NULL otherwise.
 308  *
 309  * @return
 310  *   0 on success, or -1 on failure and errno is set.
 311  */
 312 static inline int
 313 mlx5_flow_os_create_flow_action_count(void *cnt_obj, uint16_t offset,
 314                                       void **action)
 315 {
 316         *action = mlx5_glue->dv_create_flow_action_counter(cnt_obj, offset);
 317         return (*action) ? 0 : -1;
 318 }
 319
 320 /**
 321  * Create flow action: tag.
 322  *
 323  * @param[in] tag
 324  *   Tag value.
 325  * @param[out] action
 326  *   Pointer to a valid action on success, NULL otherwise.
 327  *
 328  * @return
 329  *   0 on success, or -1 on failure and errno is set.
 330  */
 331 static inline int
 332 mlx5_flow_os_create_flow_action_tag(uint32_t tag, void **action)
 333 {
 334         *action = mlx5_glue->dv_create_flow_action_tag(tag);
 335         return (*action) ? 0 : -1;
 336 }
 337
 338 /**
 339  * Create flow action: drop.
 340  *
 341  * @param[out] action
 342  *   Pointer to a valid action on success, NULL otherwise.
 343  *
 344  * @return
 345  *   0 on success, or -1 on failure and errno is set.
 346  */
 347 static inline int
 348 mlx5_flow_os_create_flow_action_drop(void **action)
 349 {
 350         *action = mlx5_glue->dr_create_flow_action_drop();
 351         return (*action) ? 0 : -1;
 352 }
 353
 354 /**
 355  * Create flow action: default miss.
 356  *
 357  * @param[out] action
 358  *   Pointer to a valid action on success, NULL otherwise.
 359  *
 360  * @return
 361  *   0 on success, or -1 on failure and errno is set.
 362  */
 363 static inline int
 364 mlx5_flow_os_create_flow_action_default_miss(void **action)
 365 {
 366         *action = mlx5_glue->dr_create_flow_action_default_miss();
 367         return (*action) ? 0 : -1;
 368 }
 369
 370 /**
 371  * Create flow action: dest_devx_tir
 372  *
 373  * @param[in] tir
 374  *   Pointer to DevX tir object
 375  * @param[out] action
 376  *   Pointer to a valid action on success, NULL otherwise.
 377  *
 378  * @return
 379  *   0 on success, or -1 on failure and errno is set.
 380  */
 381 static inline int
 382 mlx5_flow_os_create_flow_action_dest_devx_tir(struct mlx5_devx_obj *tir,
 383                                               void **action)
 384 {
 385 #ifdef HAVE_IBV_FLOW_DV_SUPPORT
 386         *action = mlx5_glue->dv_create_flow_action_dest_devx_tir(tir->obj);
 387         return (*action) ? 0 : -1;
 388 #else
 389         /* If no DV support - skip the operation and return success */
 390         RTE_SET_USED(tir);
 391         *action = 0;
 392         return 0;
 393 #endif
 394 }
 395
 396 /**
 397  * Create flow action: sampler
 398  *
 399  * @param[in] attr
 400  *   Pointer to sampler attribute
 401  * @param[out] action
 402  *   Pointer to a valid action on success, NULL otherwise.
 403  *
 404  * @return
 405  *   0 on success, or -1 on failure and errno is set.
 406  */
 407 static inline int
 408 mlx5_os_flow_dr_create_flow_action_sampler
 409                         (struct mlx5dv_dr_flow_sampler_attr *attr,
 410                         void **action)
 411 {
 412         *action = mlx5_glue->dr_create_flow_action_sampler(attr);
 413         return (*action) ? 0 : -1;
 414 }
 415
 416 /**
 417  * Create flow action: dest_array
 418  *
 419  * @param[in] domain
 420  *   Pointer to relevant domain.
 421  * @param[in] num_dest
 422  *   Number of destinations array.
 423  * @param[in] dests
 424  *   Array of destination attributes.
 425  * @param[out] action
 426  *   Pointer to a valid action on success, NULL otherwise.
 427  *
 428  * @return
 429  *   0 on success, or -1 on failure and errno is set.
 430  */
 431 static inline int
 432 mlx5_os_flow_dr_create_flow_action_dest_array
 433                         (void *domain,
 434                          size_t num_dest,
 435                          struct mlx5dv_dr_action_dest_attr *dests[],
 436                          void **action)
 437 {
 438         *action = mlx5_glue->dr_create_flow_action_dest_array(
 439                                                 domain, num_dest, dests);
 440         return (*action) ? 0 : -1;
 441 }
 442
 443 /**
 444  * Destroy flow action.
 445  *
 446  * @param[in] action
 447  *   Pointer to action object to destroy.
 448  *
 449  * @return
 450  *   0 on success, or the value of errno on failure.
 451  */
 452 static inline int
 453 mlx5_flow_os_destroy_flow_action(void *action)
 454 {
 455         return mlx5_glue->destroy_flow_action(action);
 456 }
 457
 458 /**
 459  * OS wrapper over Verbs API.
 460  * Adjust flow priority based on the highest layer and the request priority.
 461  *
 462  * @param[in] dev
 463  *    Pointer to the Ethernet device structure.
 464  * @param[in] priority
 465  *    The rule base priority.
 466  * @param[in] subpriority
 467  *    The priority based on the items.
 468  *
 469  * @return
 470  *    The new priority.
 471  */
 472 static inline uint32_t
 473 mlx5_os_flow_adjust_priority(struct rte_eth_dev *dev, int32_t priority,
 474                           uint32_t subpriority)
 475 {
 476         return mlx5_flow_adjust_priority(dev, priority, subpriority);
 477 }
 478
 479 static inline int
 480 mlx5_os_flow_dr_sync_domain(void *domain, uint32_t flags)
 481 {
 482         return mlx5_glue->dr_sync_domain(domain, flags);
 483 }
 484 #endif /* RTE_PMD_MLX5_FLOW_OS_H_ */