Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2020 Mellanox Technologies, Ltd
       3                 :            :  *
       4                 :            :  * The file contains the implementations of the method to
       5                 :            :  * fill items, actions & attributes in their corresponding
       6                 :            :  * arrays, and then generate rte_flow rule.
       7                 :            :  *
       8                 :            :  * After the generation. The rule goes to validation then
       9                 :            :  * creation state and then return the results.
      10                 :            :  */
      11                 :            : 
      12                 :            : #include <stdint.h>
      13                 :            : 
      14                 :            : #include "flow_gen.h"
      15                 :            : #include "items_gen.h"
      16                 :            : #include "actions_gen.h"
      17                 :            : #include "config.h"
      18                 :            : 
      19                 :            : static void
      20                 :          0 : fill_attributes(struct rte_flow_attr *attr,
      21                 :            :         uint64_t *flow_attrs, uint16_t group, uint8_t max_priority)
      22                 :            : {
      23                 :            :         uint8_t i;
      24                 :          0 :         for (i = 0; i < MAX_ATTRS_NUM; i++) {
      25                 :          0 :                 if (flow_attrs[i] == 0)
      26                 :            :                         break;
      27                 :          0 :                 if (flow_attrs[i] & INGRESS)
      28                 :          0 :                         attr->ingress = 1;
      29                 :          0 :                 else if (flow_attrs[i] & EGRESS)
      30                 :          0 :                         attr->egress = 1;
      31                 :          0 :                 else if (flow_attrs[i] & TRANSFER)
      32                 :          0 :                         attr->transfer = 1;
      33                 :            :         }
      34                 :          0 :         attr->group = group;
      35                 :          0 :         attr->priority = rte_rand_max(max_priority);
      36                 :          0 : }
      37                 :            : 
      38                 :            : struct rte_flow *
      39                 :          0 : generate_flow(uint16_t port_id,
      40                 :            :         uint16_t group,
      41                 :            :         uint64_t *flow_attrs,
      42                 :            :         uint64_t *flow_items,
      43                 :            :         uint64_t *flow_actions,
      44                 :            :         uint16_t next_table,
      45                 :            :         uint32_t outer_ip_src,
      46                 :            :         uint16_t hairpinq,
      47                 :            :         uint64_t encap_data,
      48                 :            :         uint64_t decap_data,
      49                 :            :         uint16_t dst_port,
      50                 :            :         uint8_t core_idx,
      51                 :            :         uint8_t rx_queues_count,
      52                 :            :         bool unique_data,
      53                 :            :         uint8_t max_priority,
      54                 :            :         struct rte_flow_error *error)
      55                 :            : {
      56                 :            :         struct rte_flow_attr attr;
      57                 :            :         struct rte_flow_item items[MAX_ITEMS_NUM];
      58                 :            :         struct rte_flow_action actions[MAX_ACTIONS_NUM];
      59                 :            :         struct rte_flow *flow = NULL;
      60                 :            : 
      61                 :            :         memset(items, 0, sizeof(items));
      62                 :            :         memset(actions, 0, sizeof(actions));
      63                 :            :         memset(&attr, 0, sizeof(struct rte_flow_attr));
      64                 :            : 
      65                 :          0 :         fill_attributes(&attr, flow_attrs, group, max_priority);
      66                 :            : 
      67                 :          0 :         fill_actions(actions, flow_actions,
      68                 :            :                 outer_ip_src, next_table, hairpinq,
      69                 :            :                 encap_data, decap_data, core_idx,
      70                 :            :                 unique_data, rx_queues_count, dst_port);
      71                 :            : 
      72                 :          0 :         fill_items(items, flow_items, outer_ip_src, core_idx);
      73                 :            : 
      74                 :          0 :         flow = rte_flow_create(port_id, &attr, items, actions, error);
      75                 :          0 :         return flow;
      76                 :            : }