doc/guides/sample_app_ug/vmdq_dcb_forwarding.rst

   1 ..  BSD LICENSE
   2     Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   3     All rights reserved.
   4
   5     Redistribution and use in source and binary forms, with or without
   6     modification, are permitted provided that the following conditions
   7     are met:
   8
   9     * Redistributions of source code must retain the above copyright
  10     notice, this list of conditions and the following disclaimer.
  11     * Redistributions in binary form must reproduce the above copyright
  12     notice, this list of conditions and the following disclaimer in
  13     the documentation and/or other materials provided with the
  14     distribution.
  15     * Neither the name of Intel Corporation nor the names of its
  16     contributors may be used to endorse or promote products derived
  17     from this software without specific prior written permission.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22     A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23     OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25     LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26     DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27     THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 VMDQ and DCB Forwarding Sample Application
  32 ==========================================
  33
  34 The VMDQ and DCB Forwarding sample application is a simple example of packet processing using the DPDK.
  35 The application performs L2 forwarding using VMDQ and DCB to divide the incoming traffic into 128 queues.
  36 The traffic splitting is performed in hardware by the VMDQ and DCB features of the Intel® 82599 10 Gigabit Ethernet Controller.
  37
  38 Overview
  39 --------
  40
  41 This sample application can be used as a starting point for developing a new application that is based on the DPDK and
  42 uses VMDQ and DCB for traffic partitioning.
  43
  44 The VMDQ and DCB filters work on VLAN traffic to divide the traffic into 128 input queues on the basis of the VLAN ID field and
  45 VLAN user priority field.
  46 VMDQ filters split the traffic into 16 or 32 groups based on the VLAN ID.
  47 Then, DCB places each packet into one of either 4 or 8 queues within that group, based upon the VLAN user priority field.
  48
  49 In either case, 16 groups of 8 queues, or 32 groups of 4 queues, the traffic can be split into 128 hardware queues on the NIC,
  50 each of which can be polled individually by a DPDK application.
  51
  52 All traffic is read from a single incoming port (port 0) and output on port 1, without any processing being performed.
  53 The traffic is split into 128 queues on input, where each thread of the application reads from multiple queues.
  54 For example, when run with 8 threads, that is, with the -c FF option, each thread receives and forwards packets from 16 queues.
  55
  56 As supplied, the sample application configures the VMDQ feature to have 16 pools with 8 queues each as indicated in Figure 15.
  57 The Intel® 82599 10 Gigabit Ethernet Controller NIC also supports the splitting of traffic into 32 pools of 4 queues each and
  58 this can be used by changing the NUM_POOLS parameter in the supplied code.
  59 The NUM_POOLS parameter can be passed on the command line, after the EAL parameters:
  60
  61 .. code-block:: console
  62
  63     ./build/vmdq_dcb [EAL options] -- -p PORTMASK --nb-pools NP
  64
  65 where, NP can be 16 or 32.
  66
  67 .. _figure_15:
  68
  69 **Figure 15. Packet Flow Through the VMDQ and DCB Sample Application**
  70
  71 .. image18_png has been replaced
  72
  73 |vmdq_dcb_example|
  74
  75 In Linux* user space, the application can display statistics with the number of packets received on each queue.
  76 To have the application display the statistics, send a SIGHUP signal to the running application process, as follows:
  77
  78 where, <pid> is the process id of the application process.
  79
  80 The VMDQ and DCB Forwarding sample application is in many ways simpler than the L2 Forwarding application
  81 (see Chapter 9 , "L2 Forwarding Sample Application (in Real and Virtualized Environments)")
  82 as it performs unidirectional L2 forwarding of packets from one port to a second port.
  83 No command-line options are taken by this application apart from the standard EAL command-line options.
  84
  85 .. note::
  86
  87     Since VMD queues are being used for VMM, this application works correctly
  88     when VTd is disabled in the BIOS or Linux* kernel (intel_iommu=off).
  89
  90 Compiling the Application
  91 -------------------------
  92
  93 #.  Go to the examples directory:
  94
  95     .. code-block:: console
  96
  97         export RTE_SDK=/path/to/rte_sdk cd ${RTE_SDK}/examples/vmdq_dcb
  98
  99 #.  Set the target (a default target is used if not specified). For example:
 100
 101     .. code-block:: console
 102
 103         export RTE_TARGET=x86_64-native-linuxapp-gcc
 104
 105     See the *DPDK Getting Started Guide* for possible RTE_TARGET values.
 106
 107 #.  Build the application:
 108
 109     .. code-block:: console
 110
 111         make
 112
 113 Running the Application
 114 -----------------------
 115
 116 To run the example in a linuxapp environment:
 117
 118 .. code-block:: console
 119
 120     user@target:~$ ./build/vmdq_dcb -c f -n 4 -- -p 0x3 --nb-pools 16
 121
 122 Refer to the *DPDK Getting Started Guide* for general information on running applications and
 123 the Environment Abstraction Layer (EAL) options.
 124
 125 Explanation
 126 -----------
 127
 128 The following sections provide some explanation of the code.
 129
 130 Initialization
 131 ~~~~~~~~~~~~~~
 132
 133 The EAL, driver and PCI configuration is performed largely as in the L2 Forwarding sample application,
 134 as is the creation of the mbuf pool.
 135 See Chapter 9, "L2 Forwarding Sample Application (in Real and Virtualized Environments)".
 136 Where this example application differs is in the configuration of the NIC port for RX.
 137
 138 The VMDQ and DCB hardware feature is configured at port initialization time by setting the appropriate values in the
 139 rte_eth_conf structure passed to the rte_eth_dev_configure() API.
 140 Initially in the application,
 141 a default structure is provided for VMDQ and DCB configuration to be filled in later by the application.
 142
 143 .. code-block:: c
 144
 145     /* empty vmdq+dcb configuration structure. Filled in programmatically */
 146
 147     static const struct rte_eth_conf vmdq_dcb_conf_default = {
 148         .rxmode = {
 149             .mq_mode = ETH_VMDQ_DCB,
 150             .split_hdr_size = 0,
 151             .header_split = 0,   /**< Header Split disabled */
 152             .hw_ip_checksum = 0, /**< IP checksum offload disabled */
 153             .hw_vlan_filter = 0, /**< VLAN filtering disabled */
 154            .jumbo_frame = 0,     /**< Jumbo Frame Support disabled */
 155         },
 156
 157         .txmode = {
 158             .mq_mode = ETH_DCB_NONE,
 159         },
 160
 161         .rx_adv_conf = {
 162             /*
 163              *    should be overridden separately in code with
 164              *    appropriate values
 165              */
 166
 167             .vmdq_dcb_conf = {
 168                 .nb_queue_pools = ETH_16_POOLS,
 169                 .enable_default_pool = 0,
 170                 .default_pool = 0,
 171                 .nb_pool_maps = 0,
 172                 .pool_map = {{0, 0},},
 173                 .dcb_queue = {0},
 174             },
 175         },
 176     };
 177
 178 The get_eth_conf() function fills in an rte_eth_conf structure with the appropriate values,
 179 based on the global vlan_tags array,
 180 and dividing up the possible user priority values equally among the individual queues
 181 (also referred to as traffic classes) within each pool, that is,
 182 if the number of pools is 32, then the user priority fields are allocated two to a queue.
 183 If 16 pools are used, then each of the 8 user priority fields is allocated to its own queue within the pool.
 184 For the VLAN IDs, each one can be allocated to possibly multiple pools of queues,
 185 so the pools parameter in the rte_eth_vmdq_dcb_conf structure is specified as a bitmask value.
 186
 187 .. code-block:: c
 188
 189     const uint16_t vlan_tags[] = {
 190         0, 1, 2, 3, 4, 5, 6, 7,
 191         8, 9, 10, 11, 12, 13, 14, 15,
 192         16, 17, 18, 19, 20, 21, 22, 23,
 193         24, 25, 26, 27, 28, 29, 30, 31
 194     };
 195
 196
 197     /* Builds up the correct configuration for vmdq+dcb based on the vlan tags array
 198      * given above, and the number of traffic classes available for use. */
 199
 200     static inline int
 201     get_eth_conf(struct rte_eth_conf *eth_conf, enum rte_eth_nb_pools num_pools)
 202     {
 203         struct rte_eth_vmdq_dcb_conf conf;
 204         unsigned i;
 205
 206         if (num_pools != ETH_16_POOLS && num_pools != ETH_32_POOLS ) return -1;
 207
 208         conf.nb_queue_pools = num_pools;
 209         conf.enable_default_pool = 0;
 210         conf.default_pool = 0; /* set explicit value, even if not used */
 211         conf.nb_pool_maps = sizeof( vlan_tags )/sizeof( vlan_tags[ 0 ]);
 212
 213         for (i = 0; i < conf.nb_pool_maps; i++){
 214             conf.pool_map[i].vlan_id = vlan_tags[ i ];
 215             conf.pool_map[i].pools = 1 << (i % num_pools);
 216         }
 217
 218         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++){
 219             conf.dcb_queue[i] = (uint8_t)(i % (NUM_QUEUES/num_pools));
 220         }
 221
 222         (void) rte_memcpy(eth_conf, &vmdq_dcb_conf_default, sizeof(\*eth_conf));
 223         (void) rte_memcpy(&eth_conf->rx_adv_conf.vmdq_dcb_conf, &conf, sizeof(eth_conf->rx_adv_conf.vmdq_dcb_conf));
 224
 225         return 0;
 226     }
 227
 228 Once the network port has been initialized using the correct VMDQ and DCB values,
 229 the initialization of the port's RX and TX hardware rings is performed similarly to that
 230 in the L2 Forwarding sample application.
 231 See Chapter 9, "L2 Forwarding Sample Application (in Real and Virtualized Environments)" for more information.
 232
 233 Statistics Display
 234 ~~~~~~~~~~~~~~~~~~
 235
 236 When run in a linuxapp environment,
 237 the VMDQ and DCB Forwarding sample application can display statistics showing the number of packets read from each RX queue.
 238 This is provided by way of a signal handler for the SIGHUP signal,
 239 which simply prints to standard output the packet counts in grid form.
 240 Each row of the output is a single pool with the columns being the queue number within that pool.
 241
 242 To generate the statistics output, use the following command:
 243
 244 .. code-block:: console
 245
 246     user@host$ sudo killall -HUP vmdq_dcb_app
 247
 248 Please note that the statistics output will appear on the terminal where the vmdq_dcb_app is running,
 249 rather than the terminal from which the HUP signal was sent.
 250
 251 .. |vmdq_dcb_example| image:: img/vmdq_dcb_example.*