[dpdk-dev,v3] examples/flow_filtering: demo of simple rte flow

Message ID 01c7d2e959bcf30471c81ad9ec559aede03cfac9.1509525968.git.orika@mellanox.com
State Accepted, archived
Headers show

Checks

Context Check Description
ci/Intel-compilation success Compilation OK
ci/checkpatch warning coding style issues

Commit Message

Ori Kam Nov. 1, 2017, 9:42 a.m.
This application shows a simple usage of the
rte_flow API for hardware filtering offloading.

In this demo we are filtering specific IP to
specific target queue, while sending all the
rest of the packets to other queue.

Signed-off-by: Ori Kam <orika@mellanox.com>
---
v3:
  * Fix the position of the example doc according to alphabetical order.
  * Fix the position of the example ine the Makefile to alphabetical order.
  * Add license header to example make file.
  * Fix CFLAGS typo.
  * Fix copyright in main.c

v2:
  * Merge patches into one patch.
  * Add flow_filtering doc to index.
  * Add example to Makefile.
  * Small fixes.
  * Remove cover letter.

 MAINTAINERS                                 |   4 +
 doc/guides/sample_app_ug/flow_filtering.rst | 545 ++++++++++++++++++++++++++++
 doc/guides/sample_app_ug/index.rst          |   1 +
 examples/Makefile                           |   1 +
 examples/flow_filtering/Makefile            |  49 +++
 examples/flow_filtering/flow_blocks.c       | 150 ++++++++
 examples/flow_filtering/main.c              | 244 +++++++++++++
 7 files changed, 994 insertions(+)
 create mode 100644 doc/guides/sample_app_ug/flow_filtering.rst
 create mode 100644 examples/flow_filtering/Makefile
 create mode 100644 examples/flow_filtering/flow_blocks.c
 create mode 100644 examples/flow_filtering/main.c

Comments

Thomas Monjalon Nov. 7, 2017, 9:32 p.m. | #1
01/11/2017 10:42, Ori Kam:
> This application shows a simple usage of the
> rte_flow API for hardware filtering offloading.
> 
> In this demo we are filtering specific IP to
> specific target queue, while sending all the
> rest of the packets to other queue.
> 
> Signed-off-by: Ori Kam <orika@mellanox.com>

Applied, thanks

Patch

diff --git a/MAINTAINERS b/MAINTAINERS
index 2a58378..976252e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -914,6 +914,10 @@  F: doc/guides/sample_app_ug/ethtool.rst
 F: examples/exception_path/
 F: doc/guides/sample_app_ug/exception_path.rst
 
+M: Ori Kam <orika@mellanox.com>
+F: examples/flow_filtering/
+F: doc/guides/sample_app_ug/flow_filtering.rst
+
 M: Bruce Richardson <bruce.richardson@intel.com>
 M: Pablo de Lara <pablo.de.lara.guarch@intel.com>
 F: examples/helloworld/
diff --git a/doc/guides/sample_app_ug/flow_filtering.rst b/doc/guides/sample_app_ug/flow_filtering.rst
new file mode 100644
index 0000000..725dcb4
--- /dev/null
+++ b/doc/guides/sample_app_ug/flow_filtering.rst
@@ -0,0 +1,545 @@ 
+..  BSD LICENSE
+    Copyright(c) 2017 Mellanox Corporation. All rights reserved.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in
+    the documentation and/or other materials provided with the
+    distribution.
+    * Neither the name of Mellanox Corporation nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+Basic RTE Flow Filtering Sample Application
+===========================================
+
+The Basic RTE flow filtering sample application is a simple example of a
+creating a RTE flow rule.
+
+It is intended as a demonstration of the basic components RTE flow rules.
+
+
+Compiling the Application
+-------------------------
+
+To compile the application export the path to the DPDK source tree and go to
+the example directory:
+
+.. code-block:: console
+
+    export RTE_SDK=/path/to/rte_sdk
+
+    cd ${RTE_SDK}/examples/flow_filtering
+
+Set the target, for example:
+
+.. code-block:: console
+
+    export RTE_TARGET=x86_64-native-linuxapp-gcc
+
+See the *DPDK Getting Started* Guide for possible ``RTE_TARGET`` values.
+
+Build the application as follows:
+
+.. code-block:: console
+
+    make
+
+
+Running the Application
+-----------------------
+
+To run the example in a ``linuxapp`` environment:
+
+.. code-block:: console
+
+    ./build/flow -l 1 -n 1
+
+Refer to *DPDK Getting Started Guide* for general information on running
+applications and the Environment Abstraction Layer (EAL) options.
+
+
+Explanation
+-----------
+
+The example is build from 2 main files,
+``main.c`` which holds the example logic and ``flow_blocks.c`` that holds the
+implementation for building the flow rule.
+
+The following sections provide an explanation of the main components of the
+code.
+
+All DPDK library functions used in the sample code are prefixed with ``rte_``
+and are explained in detail in the *DPDK API Documentation*.
+
+
+The Main Function
+~~~~~~~~~~~~~~~~~
+
+The ``main()`` function located in ``main.c`` file performs the initialization
+and runs the main loop function.
+
+The first task is to initialize the Environment Abstraction Layer (EAL).  The
+``argc`` and ``argv`` arguments are provided to the ``rte_eal_init()``
+function. The value returned is the number of parsed arguments:
+
+.. code-block:: c
+
+    int ret = rte_eal_init(argc, argv);
+    if (ret < 0)
+        rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
+
+
+The ``main()`` also allocates a mempool to hold the mbufs (Message Buffers)
+used by the application:
+
+.. code-block:: c
+
+   mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", 4096, 128, 0,
+                                            RTE_MBUF_DEFAULT_BUF_SIZE,
+                                            rte_socket_id());
+
+Mbufs are the packet buffer structure used by DPDK. They are explained in
+detail in the "Mbuf Library" section of the *DPDK Programmer's Guide*.
+
+The ``main()`` function also initializes all the ports using the user defined
+``init_port()`` function which is explained in the next section:
+
+.. code-block:: c
+
+   init_port();
+
+Once the initialization is complete, we set the flow rule using the
+following code:
+
+.. code-block:: c
+
+   /* create flow for send packet with */
+   flow = generate_ipv4_flow(port_id, selected_queue,
+                                SRC_IP, EMPTY_MASK,
+                                DEST_IP, FULL_MASK, &error);
+   if (!flow) {
+          printf("Flow can't be created %d message: %s\n",
+                       error.type,
+                       error.message ? error.message : "(no stated reason)");
+          rte_exit(EXIT_FAILURE, "error in creating flow");
+   }
+
+In the last part the application is ready to launch the
+``main_loop()`` function. Which is explained below.
+
+
+.. code-block:: c
+
+   main_loop();
+
+The Port Initialization  Function
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The main functional part of the port initialization used in the flow filtering
+application is shown below:
+
+.. code-block:: c
+
+   init_port(void)
+   {
+           int ret;
+           uint16_t i;
+           struct rte_eth_conf port_conf = {
+                   .rxmode = {
+                           .split_hdr_size = 0,
+                           /**< Header Split disabled */
+                           .header_split   = 0,
+                           /**< IP checksum offload disabled */
+                           .hw_ip_checksum = 0,
+                           /**< VLAN filtering disabled */
+                           .hw_vlan_filter = 0,
+                           /**< Jumbo Frame Support disabled */
+                           .jumbo_frame    = 0,
+                           /**< CRC stripped by hardware */
+                           .hw_strip_crc   = 1,
+                   },
+           };
+
+           printf(":: initializing port: %d\n", port_id);
+           ret = rte_eth_dev_configure(port_id,
+                                   nr_queues, nr_queues, &port_conf);
+           if (ret < 0) {
+                   rte_exit(EXIT_FAILURE,
+                           ":: cannot configure device: err=%d, port=%u\n",
+                           ret, port_id);
+           }
+
+           /* only set Rx queues: something we care only so far */
+           for (i = 0; i < nr_queues; i++) {
+                   ret = rte_eth_rx_queue_setup(port_id, i, 512,
+                                        rte_eth_dev_socket_id(port_id),
+                                        NULL,
+                                        mbuf_pool);
+                   if (ret < 0) {
+                           rte_exit(EXIT_FAILURE,
+                              ":: Rx queue setup failed: err=%d, port=%u\n",
+                              ret, port_id);
+                   }
+           }
+
+
+           rte_eth_promiscuous_enable(port_id);
+
+           ret = rte_eth_dev_start(port_id);
+           if (ret < 0) {
+                   rte_exit(EXIT_FAILURE,
+                           "rte_eth_dev_start:err=%d, port=%u\n",
+                           ret, port_id);
+           }
+
+           assert_link_status();
+
+           printf(":: initializing port: %d done\n", port_id);
+   }
+
+The Ethernet port is configured with default settings using the
+``rte_eth_dev_configure()`` function and the ``port_conf_default`` struct:
+
+.. code-block:: c
+
+   struct rte_eth_conf port_conf = {
+                .rxmode = {
+                        .split_hdr_size = 0,
+                        /**< Header Split disabled */
+                        .header_split   = 0,
+                        /**< IP checksum offload disabled */
+                        .hw_ip_checksum = 0,
+                        /**< VLAN filtering disabled */
+                        .hw_vlan_filter = 0,
+                        /**< Jumbo Frame Support disabled */
+                        .jumbo_frame    = 0,
+                        /**< CRC stripped by hardware */
+                        .hw_strip_crc   = 1,
+                },
+   };
+
+   ret = rte_eth_dev_configure(port_id, nr_queues, nr_queues, &port_conf);
+   if (ret < 0) {
+        rte_exit(EXIT_FAILURE,
+                 ":: cannot configure device: err=%d, port=%u\n",
+                 ret, port_id);
+   }
+
+For this example we are configuring number of rx queues that are connected to
+a single port.
+
+.. code-block:: c
+
+   for (i = 0; i < nr_queues; i++) {
+          ret = rte_eth_rx_queue_setup(port_id, i, 512,
+                                       rte_eth_dev_socket_id(port_id),
+                                       NULL,
+                                       mbuf_pool);
+          if (ret < 0) {
+                  rte_exit(EXIT_FAILURE,
+                          ":: Rx queue setup failed: err=%d, port=%u\n",
+                          ret, port_id);
+          }
+  }
+
+In the next step we create and apply the flow rule. which is to send packets
+with destination ip equals to 192.168.1.1 to queue number 1. The detail
+explanation of the ``generate_ipv4_flow()`` appears later in this document:
+
+.. code-block:: c
+
+   flow = generate_ipv4_flow(port_id, selected_queue,
+                             SRC_IP, EMPTY_MASK,
+                             DEST_IP, FULL_MASK, &error);
+
+We are setting the RX port to promiscuous mode:
+
+.. code-block:: c
+
+   rte_eth_promiscuous_enable(port_id);
+
+The last step is to start the port.
+
+.. code-block:: c
+
+   ret = rte_eth_dev_start(port_id);
+   if (ret < 0)  {
+        rte_exit(EXIT_FAILURE, "rte_eth_dev_start:err%d, port=%u\n",
+                        ret, port_id);
+   }
+
+
+The main_loop function
+~~~~~~~~~~~~~~~~~~~~~~
+
+As we saw above the ``main()`` function calls an application function to handle
+the main loop. For the flow filtering application the main_loop function
+looks like the following:
+
+.. code-block:: c
+
+   static void
+   main_loop(void)
+   {
+           struct rte_mbuf *mbufs[32];
+           struct ether_hdr *eth_hdr;
+           uint16_t nb_rx;
+           uint16_t i;
+           uint16_t j;
+
+           while (!force_quit) {
+                   for (i = 0; i < nr_queues; i++) {
+                           nb_rx = rte_eth_rx_burst(port_id,
+                                                   i, mbufs, 32);
+                           if (nb_rx) {
+                                   for (j = 0; j < nb_rx; j++) {
+                                           struct rte_mbuf *m = mbufs[j];
+
+                                           eth_hdr = rte_pktmbuf_mtod(m,
+                                                        struct ether_hdr *);
+                                           print_ether_addr("src=",
+                                                        &eth_hdr->s_addr);
+                                           print_ether_addr(" - dst=",
+                                                        &eth_hdr->d_addr);
+                                           printf(" - queue=0x%x",
+                                                           (unsigned int)i);
+                                           printf("\n");
+                                           rte_pktmbuf_free(m);
+                                   }
+                           }
+                   }
+           }
+           /* closing and releasing resources */
+           rte_flow_flush(port_id, &error);
+           rte_eth_dev_stop(port_id);
+           rte_eth_dev_close(port_id);
+   }
+
+The main work of the application is reading the packets from all
+queues and printing for each packet the destination queue:
+
+.. code-block:: c
+
+    while (!force_quit) {
+        for (i = 0; i < nr_queues; i++) {
+                   nb_rx = rte_eth_rx_burst(port_id, i, mbufs, 32);
+                if (nb_rx) {
+                        for (j = 0; j < nb_rx; j++) {
+                             struct rte_mbuf *m = mbufs[j];
+                             eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
+                             print_ether_addr("src=", &eth_hdr->s_addr);
+                             print_ether_addr(" - dst=", &eth_hdr->d_addr);
+                             printf(" - queue=0x%x", (unsigned int)i);
+                             printf("\n");
+                             rte_pktmbuf_free(m);
+                        }
+                }
+           }
+    }
+
+
+The forwarding loop can be interrupted and the application closed using
+``Ctrl-C``. Which results in closing the port and the device using
+``rte_eth_dev_stop`` and ``rte_eth_dev_close``
+
+The generate_ipv4_flow function
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The generate_ipv4_rule function is responsible for creating the flow rule.
+This function is located in the ``flow_blocks.c`` file.
+
+.. code-block:: c
+
+   static struct rte_flow *
+   generate_ipv4_flow(uint8_t port_id, uint16_t rx_q,
+                   uint32_t src_ip, uint32_t src_mask,
+                   uint32_t dest_ip, uint32_t dest_mask,
+                   struct rte_flow_error *error)
+   {
+           struct rte_flow_attr attr;
+           struct rte_flow_item pattern[MAX_PATTERN_NUM];
+           struct rte_flow_action action[MAX_PATTERN_NUM];
+           struct rte_flow *flow = NULL;
+           struct rte_flow_action_queue queue = { .index = rx_q };
+           struct rte_flow_item_eth eth_spec;
+           struct rte_flow_item_eth eth_mask;
+           struct rte_flow_item_vlan vlan_spec;
+           struct rte_flow_item_vlan vlan_mask;
+           struct rte_flow_item_ipv4 ip_spec;
+           struct rte_flow_item_ipv4 ip_mask;
+
+           memset(pattern, 0, sizeof(pattern));
+           memset(action, 0, sizeof(action));
+
+           /*
+            * set the rule attribute.
+            * in this case only ingress packets will be checked.
+            */
+           memset(&attr, 0, sizeof(struct rte_flow_attr));
+           attr.ingress = 1;
+
+           /*
+            * create the action sequence.
+            * one action only,  move packet to queue
+            */
+
+           action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE;
+           action[0].conf = &queue;
+           action[1].type = RTE_FLOW_ACTION_TYPE_END;
+
+           /*
+            * set the first level of the pattern (eth).
+            * since in this example we just want to get the
+            * ipv4 we set this level to allow all.
+            */
+           memset(&eth_spec, 0, sizeof(struct rte_flow_item_eth));
+           memset(&eth_mask, 0, sizeof(struct rte_flow_item_eth));
+           eth_spec.type = 0;
+           eth_mask.type = 0;
+           pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;
+           pattern[0].spec = &eth_spec;
+           pattern[0].mask = &eth_mask;
+
+           /*
+            * setting the second level of the pattern (vlan).
+            * since in this example we just want to get the
+            * ipv4 we also set this level to allow all.
+            */
+           memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan));
+           memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan));
+           pattern[1].type = RTE_FLOW_ITEM_TYPE_VLAN;
+           pattern[1].spec = &vlan_spec;
+           pattern[1].mask = &vlan_mask;
+
+           /*
+            * setting the third level of the pattern (ip).
+            * in this example this is the level we care about
+            * so we set it according to the parameters.
+            */
+           memset(&ip_spec, 0, sizeof(struct rte_flow_item_ipv4));
+           memset(&ip_mask, 0, sizeof(struct rte_flow_item_ipv4));
+           ip_spec.hdr.dst_addr = htonl(dest_ip);
+           ip_mask.hdr.dst_addr = dest_mask;
+           ip_spec.hdr.src_addr = htonl(src_ip);
+           ip_mask.hdr.src_addr = src_mask;
+           pattern[2].type = RTE_FLOW_ITEM_TYPE_IPV4;
+           pattern[2].spec = &ip_spec;
+           pattern[2].mask = &ip_mask;
+
+           /* the final level must be always type end */
+           pattern[3].type = RTE_FLOW_ITEM_TYPE_END;
+
+           int res = rte_flow_validate(port_id, &attr, pattern, action, error);
+           if(!res)
+               flow = rte_flow_create(port_id, &attr, pattern, action, error);
+
+           return flow;
+   }
+
+The first part of the function is declaring the structures that will be used.
+
+.. code-block:: c
+
+   struct rte_flow_attr attr;
+   struct rte_flow_item pattern[MAX_PATTERN_NUM];
+   struct rte_flow_action action[MAX_PATTERN_NUM];
+   struct rte_flow *flow;
+   struct rte_flow_error error;
+   struct rte_flow_action_queue queue = { .index = rx_q };
+   struct rte_flow_item_eth eth_spec;
+   struct rte_flow_item_eth eth_mask;
+   struct rte_flow_item_vlan vlan_spec;
+   struct rte_flow_item_vlan vlan_mask;
+   struct rte_flow_item_ipv4 ip_spec;
+   struct rte_flow_item_ipv4 ip_mask;
+
+The following part create the flow attributes, in our case ingress.
+
+.. code-block:: c
+
+   memset(&attr, 0, sizeof(struct rte_flow_attr));
+   attr.ingress = 1;
+
+The third part defines the action to be taken when a packet matches
+the rule. In this case send the packet to queue.
+
+.. code-block:: c
+
+   action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE;
+   action[0].conf = &queue;
+   action[1].type = RTE_FLOW_ACTION_TYPE_END;
+
+The forth part is responsible for creating the pattern and is build from
+number of step. In each step we build one level of the pattern starting with
+the lowest one.
+
+Setting the first level of the pattern ETH:
+
+.. code-block:: c
+
+   memset(&eth_spec, 0, sizeof(struct rte_flow_item_eth));
+   memset(&eth_mask, 0, sizeof(struct rte_flow_item_eth));
+   eth_spec.type = 0;
+   eth_mask.type = 0;
+   pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;
+   pattern[0].spec = &eth_spec;
+   pattern[0].mask = &eth_mask;
+
+Setting the second level of the pattern VLAN:
+
+.. code-block:: c
+
+   memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan));
+   memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan));
+   pattern[1].type = RTE_FLOW_ITEM_TYPE_VLAN;
+   pattern[1].spec = &vlan_spec;
+   pattern[1].mask = &vlan_mask;
+
+Setting the third level ip:
+
+.. code-block:: c
+
+   memset(&ip_spec, 0, sizeof(struct rte_flow_item_ipv4));
+   memset(&ip_mask, 0, sizeof(struct rte_flow_item_ipv4));
+   ip_spec.hdr.dst_addr = htonl(dest_ip);
+   ip_mask.hdr.dst_addr = dest_mask;
+   ip_spec.hdr.src_addr = htonl(src_ip);
+   ip_mask.hdr.src_addr = src_mask;
+   pattern[2].type = RTE_FLOW_ITEM_TYPE_IPV4;
+   pattern[2].spec = &ip_spec;
+   pattern[2].mask = &ip_mask;
+
+Closing the pattern part.
+
+.. code-block:: c
+
+   pattern[3].type = RTE_FLOW_ITEM_TYPE_END;
+
+The last part of the function is to validate the rule and create it.
+
+.. code-block:: c
+
+   int res = rte_flow_validate(port_id, &attr, pattern, action, &error);
+   if (!res)
+        flow = rte_flow_create(port_id, &attr, pattern, action, &error);
+
diff --git a/doc/guides/sample_app_ug/index.rst b/doc/guides/sample_app_ug/index.rst
index 069d4f1..ca1f544 100644
--- a/doc/guides/sample_app_ug/index.rst
+++ b/doc/guides/sample_app_ug/index.rst
@@ -77,6 +77,7 @@  Sample Applications User Guides
     ptpclient
     performance_thread
     ipsec_secgw
+    flow_filtering
 
 **Figures**
 
diff --git a/examples/Makefile b/examples/Makefile
index d27eddd..77f84d6 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -42,6 +42,7 @@  DIRS-y += cmdline
 DIRS-$(CONFIG_RTE_LIBRTE_DISTRIBUTOR) += distributor
 DIRS-y += ethtool
 DIRS-y += exception_path
+DIRS-y += flow_filtering
 DIRS-$(CONFIG_RTE_LIBRTE_EFD) += server_node_efd
 DIRS-y += helloworld
 DIRS-$(CONFIG_RTE_LIBRTE_PIPELINE) += ip_pipeline
diff --git a/examples/flow_filtering/Makefile b/examples/flow_filtering/Makefile
new file mode 100644
index 0000000..70b82fe
--- /dev/null
+++ b/examples/flow_filtering/Makefile
@@ -0,0 +1,49 @@ 
+#
+#   BSD LICENSE
+#
+#   Copyright 2017 Mellanox.
+#
+#   Redistribution and use in source and binary forms, with or without
+#   modification, are permitted provided that the following conditions
+#   are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in
+#       the documentation and/or other materials provided with the
+#       distribution.
+#     * Neither the name of Mellanox nor the names of its
+#       contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+#   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+ifeq ($(RTE_SDK),)
+$(error "Please define RTE_SDK environment variable")
+endif
+
+# Default target, can be overridden by command line or environment
+RTE_TARGET ?= x86_64-native-linuxapp-gcc
+
+include $(RTE_SDK)/mk/rte.vars.mk
+
+APP = flow
+
+SRCS-y := main.c
+
+CFLAGS += -O3
+CFLAGS += $(WERROR_FLAGS)
+
+include $(RTE_SDK)/mk/rte.extapp.mk
diff --git a/examples/flow_filtering/flow_blocks.c b/examples/flow_filtering/flow_blocks.c
new file mode 100644
index 0000000..f92df10
--- /dev/null
+++ b/examples/flow_filtering/flow_blocks.c
@@ -0,0 +1,150 @@ 
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright 2017 Mellanox.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Mellanox nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define MAX_PATTERN_NUM		4
+
+struct rte_flow *
+generate_ipv4_flow(uint8_t port_id, uint16_t rx_q,
+		uint32_t src_ip, uint32_t src_mask,
+		uint32_t dest_ip, uint32_t dest_mask,
+		struct rte_flow_error *error);
+
+
+/**
+ * create a flow rule that sends packets with matching src and dest ip
+ * to selected queue.
+ *
+ * @param port_id
+ *   The selected port.
+ * @param rx_q
+ *   The selected target queue.
+ * @param src_ip
+ *   The src ip value to match the input packet.
+ * @param src_mask
+ *   The mask to apply to the src ip.
+ * @param dest_ip
+ *   The dest ip value to match the input packet.
+ * @param dest_mask
+ *   The mask to apply to the dest ip.
+ * @param[out] error
+ *   Perform verbose error reporting if not NULL.
+ *
+ * @return
+ *   A flow if the rule could be created else return NULL.
+ */
+struct rte_flow *
+generate_ipv4_flow(uint8_t port_id, uint16_t rx_q,
+		uint32_t src_ip, uint32_t src_mask,
+		uint32_t dest_ip, uint32_t dest_mask,
+		struct rte_flow_error *error)
+{
+	struct rte_flow_attr attr;
+	struct rte_flow_item pattern[MAX_PATTERN_NUM];
+	struct rte_flow_action action[MAX_PATTERN_NUM];
+	struct rte_flow *flow = NULL;
+	struct rte_flow_action_queue queue = { .index = rx_q };
+	struct rte_flow_item_eth eth_spec;
+	struct rte_flow_item_eth eth_mask;
+	struct rte_flow_item_vlan vlan_spec;
+	struct rte_flow_item_vlan vlan_mask;
+	struct rte_flow_item_ipv4 ip_spec;
+	struct rte_flow_item_ipv4 ip_mask;
+	int res;
+
+	memset(pattern, 0, sizeof(pattern));
+	memset(action, 0, sizeof(action));
+
+	/*
+	 * set the rule attribute.
+	 * in this case only ingress packets will be checked.
+	 */
+	memset(&attr, 0, sizeof(struct rte_flow_attr));
+	attr.ingress = 1;
+
+	/*
+	 * create the action sequence.
+	 * one action only,  move packet to queue
+	 */
+
+	action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE;
+	action[0].conf = &queue;
+	action[1].type = RTE_FLOW_ACTION_TYPE_END;
+
+	/*
+	 * set the first level of the pattern (eth).
+	 * since in this example we just want to get the
+	 * ipv4 we set this level to allow all.
+	 */
+	memset(&eth_spec, 0, sizeof(struct rte_flow_item_eth));
+	memset(&eth_mask, 0, sizeof(struct rte_flow_item_eth));
+	eth_spec.type = 0;
+	eth_mask.type = 0;
+	pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH;
+	pattern[0].spec = &eth_spec;
+	pattern[0].mask = &eth_mask;
+
+	/*
+	 * setting the second level of the pattern (vlan).
+	 * since in this example we just want to get the
+	 * ipv4 we also set this level to allow all.
+	 */
+	memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan));
+	memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan));
+	pattern[1].type = RTE_FLOW_ITEM_TYPE_VLAN;
+	pattern[1].spec = &vlan_spec;
+	pattern[1].mask = &vlan_mask;
+
+	/*
+	 * setting the third level of the pattern (ip).
+	 * in this example this is the level we care about
+	 * so we set it according to the parameters.
+	 */
+	memset(&ip_spec, 0, sizeof(struct rte_flow_item_ipv4));
+	memset(&ip_mask, 0, sizeof(struct rte_flow_item_ipv4));
+	ip_spec.hdr.dst_addr = htonl(dest_ip);
+	ip_mask.hdr.dst_addr = dest_mask;
+	ip_spec.hdr.src_addr = htonl(src_ip);
+	ip_mask.hdr.src_addr = src_mask;
+	pattern[2].type = RTE_FLOW_ITEM_TYPE_IPV4;
+	pattern[2].spec = &ip_spec;
+	pattern[2].mask = &ip_mask;
+
+	/* the final level must be always type end */
+	pattern[3].type = RTE_FLOW_ITEM_TYPE_END;
+
+	res = rte_flow_validate(port_id, &attr, pattern, action, error);
+	if (!res)
+		flow = rte_flow_create(port_id, &attr, pattern, action, error);
+
+	return flow;
+}
+
diff --git a/examples/flow_filtering/main.c b/examples/flow_filtering/main.c
new file mode 100644
index 0000000..7d739b4
--- /dev/null
+++ b/examples/flow_filtering/main.c
@@ -0,0 +1,244 @@ 
+/*-
+ *   BSD LICENSE
+ *
+ *   Copyright 2017 Mellanox.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Mellanox. nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/queue.h>
+#include <netinet/in.h>
+#include <setjmp.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <errno.h>
+#include <getopt.h>
+#include <signal.h>
+#include <stdbool.h>
+
+#include <rte_eal.h>
+#include <rte_common.h>
+#include <rte_malloc.h>
+#include <rte_ether.h>
+#include <rte_ethdev.h>
+#include <rte_mempool.h>
+#include <rte_mbuf.h>
+#include <rte_net.h>
+#include <rte_flow.h>
+
+static volatile bool force_quit;
+
+static uint8_t port_id;
+static uint16_t nr_queues = 5;
+static uint8_t selected_queue = 1;
+struct rte_mempool *mbuf_pool;
+struct rte_flow *flow;
+
+#define SRC_IP ((0<<24) + (0<<16) + (0<<8) + 0) /* src ip = 0.0.0.0 */
+#define DEST_IP ((192<<24) + (168<<16) + (1<<8) + 1) /* dest ip = 192.168.1.1 */
+#define FULL_MASK 0xffffffff /* full mask */
+#define EMPTY_MASK 0x0 /* empty mask */
+
+#include "flow_blocks.c"
+
+static inline void
+print_ether_addr(const char *what, struct ether_addr *eth_addr)
+{
+	char buf[ETHER_ADDR_FMT_SIZE];
+	ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr);
+	printf("%s%s", what, buf);
+}
+
+static void
+main_loop(void)
+{
+	struct rte_mbuf *mbufs[32];
+	struct ether_hdr *eth_hdr;
+	struct rte_flow_error error;
+	uint16_t nb_rx;
+	uint16_t i;
+	uint16_t j;
+
+	while (!force_quit) {
+		for (i = 0; i < nr_queues; i++) {
+			nb_rx = rte_eth_rx_burst(port_id,
+						i, mbufs, 32);
+			if (nb_rx) {
+				for (j = 0; j < nb_rx; j++) {
+					struct rte_mbuf *m = mbufs[j];
+
+					eth_hdr = rte_pktmbuf_mtod(m,
+							struct ether_hdr *);
+					print_ether_addr("src=",
+							&eth_hdr->s_addr);
+					print_ether_addr(" - dst=",
+							&eth_hdr->d_addr);
+					printf(" - queue=0x%x",
+							(unsigned int)i);
+					printf("\n");
+
+					rte_pktmbuf_free(m);
+				}
+			}
+		}
+	}
+
+	/* closing and releasing resources */
+	rte_flow_flush(port_id, &error);
+	rte_eth_dev_stop(port_id);
+	rte_eth_dev_close(port_id);
+}
+
+static void
+assert_link_status(void)
+{
+	struct rte_eth_link link;
+
+	memset(&link, 0, sizeof(link));
+	rte_eth_link_get(port_id, &link);
+	if (link.link_status == ETH_LINK_DOWN)
+		rte_exit(EXIT_FAILURE, ":: error: link is still down\n");
+}
+
+static void
+init_port(void)
+{
+	int ret;
+	uint16_t i;
+	struct rte_eth_conf port_conf = {
+		.rxmode = {
+			.split_hdr_size = 0,
+			/**< Header Split disabled */
+			.header_split   = 0,
+			/**< IP checksum offload disabled */
+			.hw_ip_checksum = 0,
+			/**< VLAN filtering disabled */
+			.hw_vlan_filter = 0,
+			/**< Jumbo Frame Support disabled */
+			.jumbo_frame    = 0,
+			/**< CRC stripped by hardware */
+			.hw_strip_crc   = 1,
+		},
+	};
+
+	printf(":: initializing port: %d\n", port_id);
+	ret = rte_eth_dev_configure(port_id,
+				nr_queues, nr_queues, &port_conf);
+	if (ret < 0) {
+		rte_exit(EXIT_FAILURE,
+			":: cannot configure device: err=%d, port=%u\n",
+			ret, port_id);
+	}
+
+	/* only set Rx queues: something we care only so far */
+	for (i = 0; i < nr_queues; i++) {
+		ret = rte_eth_rx_queue_setup(port_id, i, 512,
+				     rte_eth_dev_socket_id(port_id),
+				     NULL,
+				     mbuf_pool);
+		if (ret < 0) {
+			rte_exit(EXIT_FAILURE,
+				":: Rx queue setup failed: err=%d, port=%u\n",
+				ret, port_id);
+		}
+	}
+
+	rte_eth_promiscuous_enable(port_id);
+	ret = rte_eth_dev_start(port_id);
+	if (ret < 0) {
+		rte_exit(EXIT_FAILURE,
+			"rte_eth_dev_start:err=%d, port=%u\n",
+			ret, port_id);
+	}
+
+	assert_link_status();
+
+	printf(":: initializing port: %d done\n", port_id);
+}
+
+static void
+signal_handler(int signum)
+{
+	if (signum == SIGINT || signum == SIGTERM) {
+		printf("\n\nSignal %d received, preparing to exit...\n",
+				signum);
+		force_quit = true;
+	}
+}
+
+int
+main(int argc, char **argv)
+{
+	int ret;
+	uint8_t nr_ports;
+	struct rte_flow_error error;
+
+	ret = rte_eal_init(argc, argv);
+	if (ret < 0)
+		rte_exit(EXIT_FAILURE, ":: invalid EAL arguments\n");
+
+	force_quit = false;
+	signal(SIGINT, signal_handler);
+	signal(SIGTERM, signal_handler);
+
+	nr_ports = rte_eth_dev_count();
+	if (nr_ports == 0)
+		rte_exit(EXIT_FAILURE, ":: no Ethernet ports found\n");
+	port_id = 0;
+	if (nr_ports != 1) {
+		printf(":: warn: %d ports detected, but we use only one: port %u\n",
+			nr_ports, port_id);
+	}
+	mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", 4096, 128, 0,
+					    RTE_MBUF_DEFAULT_BUF_SIZE,
+					    rte_socket_id());
+	if (mbuf_pool == NULL)
+		rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");
+
+	init_port();
+
+	/* create flow for send packet with */
+	flow = generate_ipv4_flow(port_id, selected_queue,
+				SRC_IP, EMPTY_MASK,
+				DEST_IP, FULL_MASK, &error);
+	if (!flow) {
+		printf("Flow can't be created %d message: %s\n",
+			error.type,
+			error.message ? error.message : "(no stated reason)");
+		rte_exit(EXIT_FAILURE, "error in creating flow");
+	}
+
+	main_loop();
+
+	return 0;
+}