-.. BSD LICENSE
- Copyright(c) 2010-2015 Intel 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 Intel 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.
+.. SPDX-License-Identifier: BSD-3-Clause
+ Copyright(c) 2010-2015 Intel Corporation.
.. _linux_gsg_compiling_dpdk:
Parts of this process can also be done using the setup script described in
the :ref:`linux_setup_script` section of this document.
-Install the DPDK and Browse Sources
------------------------------------
+Uncompress DPDK and Browse Sources
+----------------------------------
First, uncompress the archive and move to the uncompressed DPDK source directory:
.. code-block:: console
- unzip DPDK-<version>.zip
- cd DPDK-<version>
-
- ls
- app/ config/ examples/ lib/ LICENSE.GPL LICENSE.LGPL Makefile
- mk/ scripts/ tools/
+ tar xJf dpdk-<version>.tar.xz
+ cd dpdk-<version>
The DPDK is composed of several directories:
* examples: Source code of DPDK application examples
-* config, tools, scripts, mk: Framework-related makefiles, scripts and configuration
-
-Installation of DPDK Target Environments
-----------------------------------------
+* config, buildtools, mk: Framework-related makefiles, scripts and configuration
-The format of a DPDK target is::
+Compiling and Installing DPDK System-wide
+-----------------------------------------
- ARCH-MACHINE-EXECENV-TOOLCHAIN
+DPDK can be configured, built and installed on your system using the tools
+``meson`` and ``ninja``.
-where:
+.. note::
-* ``ARCH`` can be: ``i686``, ``x86_64``, ``ppc_64``
+ The older makefile-based build system used in older DPDK releases is
+ still present and its use is described in section
+ `Installation of DPDK Target Environment using Make`_.
-* ``MACHINE`` can be: ``native``, ``ivshmem``, ``power8``
+DPDK Configuration
+~~~~~~~~~~~~~~~~~~
-* ``EXECENV`` can be: ``linuxapp``, ``bsdapp``
+To configure a DPDK build use:
-* ``TOOLCHAIN`` can be: ``gcc``, ``icc``
-
-The targets to be installed depend on the 32-bit and/or 64-bit packages and compilers installed on the host.
-Available targets can be found in the DPDK/config directory.
-The defconfig\_ prefix should not be used.
+.. code-block:: console
-.. note::
+ meson <options> build
- Configuration files are provided with the ``RTE_MACHINE`` optimization level set.
- Within the configuration files, the ``RTE_MACHINE`` configuration value is set to native,
- which means that the compiled software is tuned for the platform on which it is built.
- For more information on this setting, and its possible values, see the *DPDK Programmers Guide*.
+where "build" is the desired output build directory, and "<options>" can be
+empty or one of a number of meson or DPDK-specific build options, described
+later in this section. The configuration process will finish with a summary
+of what DPDK libraries and drivers are to be built and installed, and for
+each item disabled, a reason why that is the case. This information can be
+used, for example, to identify any missing required packages for a driver.
-When using the Intel® C++ Compiler (icc), one of the following commands should be invoked for 64-bit or 32-bit use respectively.
-Notice that the shell scripts update the ``$PATH`` variable and therefore should not be performed in the same session.
-Also, verify the compiler's installation directory since the path may be different:
+Once configured, to build and then install DPDK system-wide use:
.. code-block:: console
- source /opt/intel/bin/iccvars.sh intel64
- source /opt/intel/bin/iccvars.sh ia32
+ cd build
+ ninja
+ ninja install
+ ldconfig
-To install and make targets, use the ``make install T=<target>`` command in the top-level DPDK directory.
+The last two commands above generally need to be run as root,
+with the `ninja install` step copying the built objects to their final system-wide locations,
+and the last step causing the dynamic loader `ld.so` to update its cache to take account of the new objects.
-For example, to compile a 64-bit target using icc, run:
+.. note::
-.. code-block:: console
+ On some linux distributions, such as Fedora or Redhat, paths in `/usr/local` are
+ not in the default paths for the loader. Therefore, on these
+ distributions, `/usr/local/lib` and `/usr/local/lib64` should be added
+ to a file in `/etc/ld.so.conf.d/` before running `ldconfig`.
- make install T=x86_64-native-linuxapp-icc
-To compile a 32-bit build using gcc, the make command should be:
+Adjusting Build Options
+~~~~~~~~~~~~~~~~~~~~~~~
-.. code-block:: console
+DPDK has a number of options that can be adjusted as part of the build configuration process.
+These options can be listed by running ``meson configure`` inside a configured build folder.
+Many of these options come from the "meson" tool itself and can be seen documented on the
+`Meson Website <https://mesonbuild.com/Builtin-options.html>`_.
- make install T=i686-native-linuxapp-gcc
+For example, to change the build-type from the default, "debugoptimized",
+to a regular "debug" build, you can either:
-To prepare a target without building it, for example, if the configuration changes need to be made before compilation,
-use the ``make config T=<target>`` command:
+* pass ``-Dbuildtype=debug`` or ``--buildtype=debug`` to meson when configuring the build folder initially
-.. code-block:: console
+* run ``meson configure -Dbuildtype=debug`` inside the build folder after the initial meson run.
- make config T=x86_64-native-linuxapp-gcc
+Other options are specific to the DPDK project but can be adjusted similarly.
+To set the "max_lcores" value to 256, for example, you can either:
-.. warning::
+* pass ``-Dmax_lcores=256`` to meson when configuring the build folder initially
- Any kernel modules to be used, e.g. ``igb_uio``, ``kni``, must be compiled with the
- same kernel as the one running on the target.
- If the DPDK is not being built on the target machine,
- the ``RTE_KERNELDIR`` environment variable should be used to point the compilation at a copy of the kernel version to be used on the target machine.
+* run ``meson configure -Dmax_lcores=256`` inside the build folder after the initial meson run.
-Once the target environment is created, the user may move to the target environment directory and continue to make code changes and re-compile.
-The user may also make modifications to the compile-time DPDK configuration by editing the .config file in the build directory.
-(This is a build-local copy of the defconfig file from the top- level config directory).
+Some of the DPDK sample applications in the `examples` directory can be
+automatically built as part of a meson build too.
+To do so, pass a comma-separated list of the examples to build to the
+`-Dexamples` meson option as below::
-.. code-block:: console
+ meson -Dexamples=l2fwd,l3fwd build
- cd x86_64-native-linuxapp-gcc
- vi .config
- make
+As with other meson options, this can also be set post-initial-config using `meson configure` in the build directory.
+There is also a special value "all" to request that all example applications whose
+dependencies are met on the current system are built.
+When `-Dexamples=all` is set as a meson option, meson will check each example application to see if it can be built,
+and add all which can be built to the list of tasks in the ninja build configuration file.
-In addition, the make clean command can be used to remove any existing compiled files for a subsequent full, clean rebuild of the code.
+Building Applications Using Installed DPDK
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Browsing the Installed DPDK Environment Target
-----------------------------------------------
+When installed system-wide, DPDK provides a pkg-config file ``libdpdk.pc`` for applications to query as part of their build.
+It's recommended that the pkg-config file be used, rather than hard-coding the parameters (cflags/ldflags)
+for DPDK into the application build process.
-Once a target is created it contains all libraries, including poll-mode drivers, and header files for the DPDK environment that are required to build customer applications.
-In addition, the test and testpmd applications are built under the build/app directory, which may be used for testing.
-A kmod directory is also present that contains kernel modules which may be loaded if needed.
+An example of how to query and use the pkg-config file can be found in the ``Makefile`` of each of the example applications included with DPDK.
+A simplified example snippet is shown below, where the target binary name has been stored in the variable ``$(APP)``
+and the sources for that build are stored in ``$(SRCS-y)``.
-.. code-block:: console
+.. code-block:: makefile
- ls x86_64-native-linuxapp-gcc
+ PKGCONF = pkg-config
- app build include kmod lib Makefile
+ CFLAGS += -O3 $(shell $(PKGCONF) --cflags libdpdk)
+ LDFLAGS += $(shell $(PKGCONF) --libs libdpdk)
-Loading Modules to Enable Userspace IO for DPDK
------------------------------------------------
+ $(APP): $(SRCS-y) Makefile
+ $(CC) $(CFLAGS) $(SRCS-y) -o $@ $(LDFLAGS)
-To run any DPDK application, a suitable uio module can be loaded into the running kernel.
-In many cases, the standard ``uio_pci_generic`` module included in the Linux kernel
-can provide the uio capability. This module can be loaded using the command
+.. note::
-.. code-block:: console
+ Unlike with the older make build system, the meson system is not
+ designed to be used directly from a build directory. Instead it is
+ recommended that it be installed either system-wide or to a known
+ location in the user's home directory. The install location can be set
+ using the `--prefix` meson option (default: `/usr/local`).
- sudo modprobe uio_pci_generic
+an equivalent build recipe for a simple DPDK application using meson as a
+build system is shown below:
-As an alternative to the ``uio_pci_generic``, the DPDK also includes the igb_uio
-module which can be found in the kmod subdirectory referred to above. It can
-be loaded as shown below:
+.. code-block:: python
-.. code-block:: console
+ project('dpdk-app', 'c')
- sudo modprobe uio
- sudo insmod kmod/igb_uio.ko
+ dpdk = dependency('libdpdk')
+ sources = files('main.c')
+ executable('dpdk-app', sources, dependencies: dpdk)
-.. note::
- For some devices which lack support for legacy interrupts, e.g. virtual function
- (VF) devices, the ``igb_uio`` module may be needed in place of ``uio_pci_generic``.
+Installation of DPDK Target Environment using Make
+--------------------------------------------------
-Since DPDK release 1.7 onward provides VFIO support, use of UIO is optional
-for platforms that support using VFIO.
+.. note::
-Loading VFIO Module
--------------------
+ The building of DPDK using make will be deprecated in a future release. It
+ is therefore recommended that DPDK installation is done using meson and
+ ninja as described above.
-To run an DPDK application and make use of VFIO, the ``vfio-pci`` module must be loaded:
+The format of a DPDK target is::
-.. code-block:: console
+ ARCH-MACHINE-EXECENV-TOOLCHAIN
- sudo modprobe vfio-pci
+where:
-Note that in order to use VFIO, your kernel must support it.
-VFIO kernel modules have been included in the Linux kernel since version 3.6.0 and are usually present by default,
-however please consult your distributions documentation to make sure that is the case.
+* ``ARCH`` can be: ``i686``, ``x86_64``, ``ppc_64``, ``arm64``
-Also, to use VFIO, both kernel and BIOS must support and be configured to use IO virtualization (such as Intel® VT-d).
+* ``MACHINE`` can be: ``native``, ``power8``, ``armv8a``
-For proper operation of VFIO when running DPDK applications as a non-privileged user, correct permissions should also be set up.
-This can be done by using the DPDK setup script (called dpdk-setup.sh and located in the tools directory).
+* ``EXECENV`` can be: ``linux``, ``freebsd``
-.. _linux_gsg_binding_kernel:
+* ``TOOLCHAIN`` can be: ``gcc``, ``icc``
-Binding and Unbinding Network Ports to/from the Kernel Modules
---------------------------------------------------------------
+The targets to be installed depend on the 32-bit and/or 64-bit packages and compilers installed on the host.
+Available targets can be found in the DPDK/config directory.
+The defconfig\_ prefix should not be used.
-As of release 1.4, DPDK applications no longer automatically unbind all supported network ports from the kernel driver in use.
-Instead, all ports that are to be used by an DPDK application must be bound to the
-``uio_pci_generic``, ``igb_uio`` or ``vfio-pci`` module before the application is run.
-Any network ports under Linux* control will be ignored by the DPDK poll-mode drivers and cannot be used by the application.
+.. note::
-.. warning::
+ Configuration files are provided with the ``RTE_MACHINE`` optimization level set.
+ Within the configuration files, the ``RTE_MACHINE`` configuration value is set to native,
+ which means that the compiled software is tuned for the platform on which it is built.
+ For more information on this setting, and its possible values, see the *DPDK Programmers Guide*.
- The DPDK will, by default, no longer automatically unbind network ports from the kernel driver at startup.
- Any ports to be used by an DPDK application must be unbound from Linux* control and
- bound to the ``uio_pci_generic``, ``igb_uio`` or ``vfio-pci`` module before the application is run.
+When using the Intel® C++ Compiler (icc), one of the following commands should be invoked for 64-bit or 32-bit use respectively.
+Notice that the shell scripts update the ``$PATH`` variable and therefore should not be performed in the same session.
+Also, verify the compiler's installation directory since the path may be different:
-To bind ports to the ``uio_pci_generic``, ``igb_uio`` or ``vfio-pci`` module for DPDK use,
-and then subsequently return ports to Linux* control,
-a utility script called dpdk_nic _bind.py is provided in the tools subdirectory.
-This utility can be used to provide a view of the current state of the network ports on the system,
-and to bind and unbind those ports from the different kernel modules, including the uio and vfio modules.
-The following are some examples of how the script can be used.
-A full description of the script and its parameters can be obtained by calling the script with the ``--help`` or ``--usage`` options.
-Note that the uio or vfio kernel modules to be used, should be loaded into the kernel before
-running the ``dpdk-devbind.py`` script.
+.. code-block:: console
-.. warning::
+ source /opt/intel/bin/iccvars.sh intel64
+ source /opt/intel/bin/iccvars.sh ia32
- Due to the way VFIO works, there are certain limitations to which devices can be used with VFIO.
- Mainly it comes down to how IOMMU groups work.
- Any Virtual Function device can be used with VFIO on its own, but physical devices will require either all ports bound to VFIO,
- or some of them bound to VFIO while others not being bound to anything at all.
+To install and make targets, use the ``make install T=<target>`` command in the top-level DPDK directory.
- If your device is behind a PCI-to-PCI bridge, the bridge will then be part of the IOMMU group in which your device is in.
- Therefore, the bridge driver should also be unbound from the bridge PCI device for VFIO to work with devices behind the bridge.
+For example, to compile a 64-bit target using icc, run:
-.. warning::
+.. code-block:: console
- While any user can run the dpdk-devbind.py script to view the status of the network ports,
- binding or unbinding network ports requires root privileges.
+ make install T=x86_64-native-linux-icc
-To see the status of all network ports on the system:
+To compile a 32-bit build using gcc, the make command should be:
.. code-block:: console
- ./tools/dpdk-devbind.py --status
-
- Network devices using DPDK-compatible driver
- ============================================
- 0000:82:00.0 '82599EB 10-GbE NIC' drv=uio_pci_generic unused=ixgbe
- 0000:82:00.1 '82599EB 10-GbE NIC' drv=uio_pci_generic unused=ixgbe
+ make install T=i686-native-linux-gcc
- Network devices using kernel driver
- ===================================
- 0000:04:00.0 'I350 1-GbE NIC' if=em0 drv=igb unused=uio_pci_generic *Active*
- 0000:04:00.1 'I350 1-GbE NIC' if=eth1 drv=igb unused=uio_pci_generic
- 0000:04:00.2 'I350 1-GbE NIC' if=eth2 drv=igb unused=uio_pci_generic
- 0000:04:00.3 'I350 1-GbE NIC' if=eth3 drv=igb unused=uio_pci_generic
+To prepare a target without building it, for example, if the configuration changes need to be made before compilation,
+use the ``make config T=<target>`` command:
- Other network devices
- =====================
- <none>
+.. code-block:: console
-To bind device ``eth1``,``04:00.1``, to the ``uio_pci_generic`` driver:
+ make config T=x86_64-native-linux-gcc
-.. code-block:: console
+.. warning::
- ./tools/dpdk-devbind.py --bind=uio_pci_generic 04:00.1
+ Any kernel modules to be used, e.g. ``igb_uio``, ``kni``, must be compiled with the
+ same kernel as the one running on the target.
+ If the DPDK is not being built on the target machine,
+ the ``RTE_KERNELDIR`` environment variable should be used to point the compilation at a copy of the kernel version to be used on the target machine.
-or, alternatively,
+Once the target environment is created, the user may move to the target environment directory and continue to make code changes and re-compile.
+The user may also make modifications to the compile-time DPDK configuration by editing the .config file in the build directory.
+(This is a build-local copy of the defconfig file from the top- level config directory).
.. code-block:: console
- ./tools/dpdk-devbind.py --bind=uio_pci_generic eth1
+ cd x86_64-native-linux-gcc
+ vi .config
+ make
-To restore device ``82:00.0`` to its original kernel binding:
+In addition, the make clean command can be used to remove any existing compiled files for a subsequent full, clean rebuild of the code.
-.. code-block:: console
+Browsing the Installed DPDK Environment Target
+----------------------------------------------
- ./tools/dpdk-devbind.py --bind=ixgbe 82:00.0
+Once a target is created it contains all libraries, including poll-mode drivers, and header files for the DPDK environment that are required to build customer applications.
+In addition, the test and testpmd applications are built under the build/app directory, which may be used for testing.
+A kmod directory is also present that contains kernel modules which may be loaded if needed.
git.droids-corp.org / dpdk.git / blobdiff