Correct format

Signed-off-by: Derek Su <derek.su@suse.com>

.githooks/pre-commit

@@ -1,4 +1,7 @@
 #!/bin/sh
+#  SPDX-License-Identifier: BSD-3-Clause
+#  All rights reserved.
+
 #
 # Verify what is about to be committed.
 # Called by "git commit" with no arguments.  The hook should

.githooks/pre-push

@@ -1,4 +1,7 @@
 #!/bin/sh
+#  SPDX-License-Identifier: BSD-3-Clause
+#  All rights reserved.
+
 # Verify what is about to be pushed.  Called by "git
 # push" after it has checked the remote status, but before anything has been
 # pushed.  If this script exits with a non-zero status nothing will be pushed.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,5 +1,5 @@
 ---
-name: Bug report
+name: Sighting report
 about: Create a report to help us improve. Please use the issue tracker only for reporting suspected issues.
 title: ''
 labels: 'Sighting'
@@ -7,7 +7,7 @@ assignees: ''
 
 ---
 
-# Bug report
+# Sighting report
 
 <!--- Provide a general summary of the issue in the Title above -->
 
@@ -21,12 +21,12 @@ assignees: ''
 
 ## Possible Solution
 
-<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+<!--- Not obligatory, but suggest a fix/reason for the potential issue, -->
 
 ## Steps to Reproduce
 
 <!--- Provide a link to a live example, or an unambiguous set of steps to -->
-<!--- reproduce this bug. Include code to reproduce, if relevant -->
+<!--- reproduce this sighting. Include code to reproduce, if relevant -->
 1.
 2.
 3.

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

.gitignore

@@ -39,3 +39,4 @@ PYTHON_COMMAND
 test_completions.txt
 timing.txt
 test/common/build_config.sh
+.coredump_path

.gitmodules

@@ -13,3 +13,9 @@
 [submodule "libvfio-user"]
 	path = libvfio-user
 	url = https://github.com/nutanix/libvfio-user.git
+[submodule "xnvme"]
+	path = xnvme
+	url = https://github.com/OpenMPDK/xNVMe.git
+[submodule "isa-l-crypto"]
+	path = isa-l-crypto
+	url = https://github.com/intel/isa-l_crypto

CHANGELOG.md

@@ -1,61 +1,617 @@
 # Changelog
 
-## v22.01.2: (Upcoming Release)
+## v23.05: (Upcoming Release)
 
-## v22.01.1
+### accel
 
-### dpdk
+Added API `spdk_accel_submit_xor` to perform XOR.
 
-DPDK submodule is now updated to DPDK 21.11.1. This includes fixes for DPDK vhost:
+### bdev
-CVE-2021-3839
-CVE-2022-0669
-Users are strongly encouraged to upgrade.
 
-(#2374) Added `rte_dmadev` as vhost library dependency.
+A new API `spdk_bdev_module_claim_bdev_desc` was added. Unlike `spdk_bdev_module_claim_bdev`, this
+function requires a bdev descriptor to be passed and the claim is automatically released when the
+descriptor is closed. It allows bdev modules to claim bdevs as a single writer, multiple writers, or
+multiple readers.
 
-### bdev_crypto
+### env
 
-(#2500) Fixed bdev_io double completion.
+New function `spdk_env_get_main_core` was added.
 
-### bdev_nvme
+### gpt
 
-(#2440) Fixed NULL pointer access by DTRACE when creating qpair.
+GPT bdevs now use the GPT Unique Partition ID as the bdev's UUID.
 
-(#2335) Set `ana_state_updating` only after starting read ANA log page.
+### lvol
 
-### blobstore
+New API `spdk_lvol_iter_immediate_clones` was added to iterate the clones of an lvol.
 
-(#2347) Avoid recursion when split IO immediately complete.
+New APIs `spdk_lvol_get_by_uuid` and `spdk_lvol_get_by_names` to get lvols by the lvol's UUID or
+lvstore and lvol names.
 
-### iscsi
+New `bdev_lvol_get_lvols` RPC to list logical volumes. This provides information about logical
-
+volumes without providing information about the bdevs. It is useful for listing the lvols
-(#2393) Fix a memory leak in `create_iscsi_sess()` error handling.
+associated with specific lvol stores and for listing lvols that are degraded and have no
-
+associated bdev.
-### nvme
-
-(#2371) Allocate extra request for fabrics connect.
-
-(#2465) Increase min admin queue size to 256
 
 ### nvmf
 
-(#2335) `ctrlr_get_ana_state()` now always returns optimized if ana_reporting is disabled.
+New `spdk_nvmf_request_copy_to/from_buf()` APIs have been added, which support
+iovecs, unlike the deprecated `spdk_nvmf_request_get_data()`.
 
-(#2395) Avoid a null dereference before null check in FC transport when freeing a request.
+Two functions related to Asynchronous Event and error handling have been made public:
 
-(#2471) Delay NVMe-oF TCP qpair destruction till after the socket write callback.
+-	`spdk_nvmf_ctrlr_async_event_error_event`,
+-	`spdk_nvmf_ctrlr_abort_aer`.
+
+Parameters `cb_fn` and `ctx` of `spdk_nvmf_qpair_disconnect` API are deprecated. These parameters
+will be removed in 23.09 release.
+
+### nvme
+
+New API `spdk_nvme_ns_get_format_index` was added to calculate the exact format index, that
+was used to format the namespace.
+
+Added two new APIs `spdk_nvme_ns_cmd_io_mgmt_recv` and `spdk_nvme_ns_cmd_io_mgmt_send` to
+receive and send the I/O management commands.
+
+New `spdk_nvmf_transport_create_async` was added, it accepts a callback and callback argument.
+`spdk_nvmf_transport_create` is marked deprecated.
+
+### part
+
+New API `spdk_bdev_part_construct_ext` is added and allows the bdev's UUID to be specified.
+
+### examples
+
+`examples/nvme/perf` application now accepts `--use-every-core` parameter that changes
+the existing worker and namespace association logic to access every namespace from each worker.
+This replicates behavior of bdevperf application when `-C` option is provided.
+
+### util
+
+New APIs `spdk_uuid_is_null` and `spdk_uuid_set_null` were added to compare and
+set UUID to NULL value.
+
+## v23.01
+
+### accel
+
+New library isa-l-crypto has been added, it is used by accel library in crypto operations.
+
+New functions `spdk_accel_submit_encrypt` and `spdk_accel_submit_decrypt` were added.
+
+New accel module `dpdk_cryptodev` has been added. It uses DPDK crypto PMD and support encrypt and
+decrypt operations. New RPC `dpdk_cryptodev_scan_accel_module` has been added to enable this accel module.
+
+New accel module `mlx5` was added. It implements crypto operations, enabled when SPDK is configured with
+RDMA provider is mlx5_dv and crypto support.
+
+Introduced the concept of chaining multiple accel operations together and executing them all in a
+single call.  The operation can be chained via one of the `spdk_accel_append_*` functions and then
+executed using `spdk_accel_sequence_finish`.  Currently, copy, decompress, decrypt, encrypt, and
+fill operations support this mode.  This feature is considered experimental.
+
+### bdev
+
+A new API `spkd_bdev_part_submit_request_ext` was added to specify a custom completion callback.
+
+New APIs `spdk_bdev_for_each_channel` and `spdk_bdev_for_each_channel_continue` and
+associated function pointers were added to iterate each channel of the required bdev.
+
+The RPC `bdev_get_iostat` now allows a user to query the per channel IO statistics for
+required bdev, and displays maximum and minimum latencies and I/O error counts.
+
+New `spdk_bdev_copy_blocks` and `spdk_bdev_get_max_copy` APIs to support copy commands.
+
+A new API `spdk_bdev_io_get_submit_tsc` was added to get the submit_tsc of the bdev I/O.
+
+Bdevs will no longer have UUIDs generated based on timestamp and are responsible for
+setting this field themselves. Generation of UUIDs for NVMe bdevs may be enabled by
+running `bdev_nvme_set_options` RPC with `--generate-uuids` option. These identifiers
+are based on serial number and namespace ID and will always be the same for a given
+device.
+
+A new API `spdk_bdev_channel_get_histogram` was added to get the histogram of a specified
+channel for a bdev.
+
+Converted internal use of `pthread_mutex_t` to `struct spdk_spinlock`. Consumers of bdev
+API functions must be on an SPDK thread or the program will abort. It is now enforced
+that no internal bdev locks can be held when a poller or message goes off CPU.
+
+A new RPC `bdev_reset_iostat` was added to reset I/O statistics of bdevs. Note that if one
+consumer reset I/O statistics, it affects all other consumers.
+
+Add function pointers, `dump_device_stat_json` and `reset_device_stat` to the bdev module
+function table to display and reset I/O statistics specific for the module specific bdev
+context.
+
+New APIs `spdk_bdev_reset_io_stat`, `spdk_bdev_add_io_stat` and `spdk_bdev_dump_io_stat_json`
+were added to process I/O statistics outside the generic bdev layer, especially in bdev modules.
+
+### bdev_crypto
+
+vbdev_crypto is updated to use accel framework instead of DPDK PMDs.
+
+### bdev_daos
+
+New RPC `bdev_daos_resize` was added to allow resizing the daos bdev.
+
+### bdev_malloc
+
+Both of interleaved and separated metadata are now supported by the malloc bdev module.
+
+Protection information is now supported by the malloc bdev module.
+
+### bdev_nvme
+
+Updated `bdev_nvme_set_options` RPC (and rpc.py) to support the new `transport_tos` parameter.
+
+For the active-active policy of the multipath mode, in addition to the default round-robin path
+selector, the minimum queue depth path selector was added. The minimum queue depth path selector
+selects an I/O path according to the number of outstanding requests of each nvme qpair.
+
+Added RPCs `bdev_nvme_start_mdns_discovery`, `bdev_nvme_get_mdns_discovery_info` and
+`bdev_nvme_stop_mdns_discovery` to perform Avahi based mDNS discovery service,
+as per NVMe TP 8009 - Automated Discovery of Ethernet Discovery Controllers.
+
+A new option `nvme_error_stat` was added to the `bdev_nvme_set_options` RPC to enable
+collecting NVMe error counts.
+
+Added I/O statistics per I/O path to the NVMe bdev module for NVMe bdev multipath. It can be
+enabled by a new option `io_path_stat` of RPC `bdev_nvme_set_options`.
+
+Added RPC `bdev_nvme_get_path_iostat` to get I/O statistics for IO paths of the NVMe bdev.
+
+Added `selector` parameter to `bdev_nvme_set_multipath_policy` RPC to set path selector for multipath.
+Option `round_robin` and `queue_depth` are available.
+
+Added `rr_min_io` option to RPC `bdev_nvme_set_multipath_policy`. It switches I/O to
+another path after rr_min_io I/Os are routed to current io path for the round-robin
+path selector.
+
+Added option `--io-path-stat` for RPC `bdev_nvme_set_option` to enable collecting io path stat.
+
+### bdev_raid
+
+Changed `bdev_raid_get_bdevs` RPC output format to include raid_bdev details.
+
+### bdevperf
+
+Promoted the application to example to match similar programs: fio_plugin and perf.
+It can now be found inside `examples/bdev/bdevperf`.
+
+### env
+
+Added `spdk_mempool_mem_iter` that allows to get start address and length of each memory
+chunk in order to create app-specific resources.
+
+### event
+
+Added core lock file mechanism to prevent the same CPU cores from being used by multiple
+SPDK application instances.
+
+Added `--disable-cpumask-locks` command line switch to disable CPU locks on SPDK startup.
+
+Added RPCs `framework_enable_cpumask_locks` and `framework_disable_cpumask_locks` to enable
+and disable CPU core locks in runtime.
+
+Added `--rpcs-allowed` command line option. Users can specify a comma-separated list of RPC
+names with this option to restrict allowed RPCs to only that list.
+
+Added `--vfio-vf-token` command line option to specify a VF token (UUID)
+shared between SR-IOV PF and VFs for vfio_pci driver.
+
+The `spdk_iov_xfer_*()` APIs were added for handling incremental copying between
+an iovec and a buffer.
+
+### json
+
+Added API `spdk_json_write_double` and `spdk_json_write_named_double` to allow
+for writing and decoding of the the double data type.
+
+### log
+
+Added consistent tracking of use of deprecated behavior. Deprecations continue to be
+listed in deprecation.md and now are in subsections with headers matching a tag
+used in `SPDK_LOG_DEPRECATED()` calls. When deprecated behavior is used, these
+tags will appear in SPDK's log at the warn level. As the SPDK application exits, it
+will log a summary of how many times `SPDK_LOG_DEPRECATED()` was called for each
+tag that was logged at least once.
+
+### nvme
+
+NVMe transport options were newly introduced. The NVMe transport options are defined via
+the `spdk_nvme_transport_opts` structure and configured via `spdk_nvme_transport_get_opts`
+and `spdk_nvme_transport_get_opts` functions.
+
+Shared receive queue was supported by the RDMA transport. It can be configured by
+a new NVMe transport option `rdma_srq_size`.
+
+Added `transport_tos` to `spdk_nvme_ctrlr_opts` to support setting of the "type of service"
+value in the IPv4 header. Only RDMA is supported at this time.
+
+Added API `spdk_nvme_qpair_get_num_outstanding_reqs` to get the number of outstanding reqs of
+a specified qpair.
+
+### nvmf
+
+Added API `spdk_nvmf_tgt_pause_polling` and `spdk_nvmf_tgt_resume_polling` to allow
+pausing polling on poll group of a given target.
+
+### rpc
+
+Added `spdk_rpc_set_allowlist` to restrict allowed RPCs to the specified list.
+
+### scheduler
+
+Changing scheduler from dynamic back to static is no longer possible,
+as there is no way of saving original SPDK thread distribution on reactors.
 
 ### thread
 
-(#2378) Fix double unlock in `spdk_io_device_register()`.
+Added `spdk_thread_get_app_thread` which returns the first thread that was created using
+`spdk_thread_create`.
+
+Added `spdk_thread_is_running`.  This returns `true` for a running thread, or `false` if
+its exit process has started using `spdk_thread_exit`.
+
+Added API `spdk_spin_init`, `spdk_spin_destroy`, `spdk_spin_lock`, `spdk_spin_unlock`, and
+`spdk_spin_held` to support spinlocks that are aware of the SPDK concurrency model.
+
+Added iobuf buffer pool, set of API calls for allocating data buffers across libraries.
+Please see new API `spdk_iobuf_*`.
+
+### trace
+
+New `trace_get_info` RPC was added to get name of shared memory file, list of the
+available trace point groups and mask of the available trace points for each group.
+
+### ublk device
+
+The ublk application supports the ublk kernel driver. It's implemented as a ublk backend
+in spdk_tgt and could be started with specifying configuration. See the
+[ublk](https://www.kernel.org/doc/html/latest/block/ublk.html) documentation for more details.
+
+ublk bdev could export a block device via Linux ublk. It will move this backend device into userspace
+as `/dev/ublkb*`. Before to adding ublk device, need to create ublk target by RPC method.
+
+### util
+
+New API `spdk_fd_group_get_epoll_event` that returns the epoll(7) event that
+caused a function callback in file descriptor group to execute.
+
+Added API `spdk_strarray_from_string`, `spdk_strarray_dup` and `spdk_strarray_free`
+for handling arrays of strings.
+
+A new API `spdk_strcpy_replace` was added to replace all occurrences of the search string
+with the replacement string.
+
+New API `spdk_iov_memset()` was added to memset an iovec.
+
+New API `spdk_iov_one()` was added to initialize an iovec for a single buffer.
+
+## v22.09
+
+### accel
+
+Many names were changed in the accel framework to make them consistent both with themselves and
+the rest of SPDK. The primary public header file is now named `include/spdk/accel.h`.
+
+Added a new runtime RPC `accel_get_opc_assignments` to get a list of current opcode to engine
+assignments.
+
+Added a new startup RPC `accel_assign_opc` to assign/override a specific opcode to
+an engine.
+
+### bdev
+
+New RPCs `bdev_xnvme_create` and `bdev_xnvme_delete` were added to support the xNVMe bdev.
+
+A new API `spdk_bdev_for_each_bdev_io` was added to execute the function on the appropriate
+thread for each bdev_io submitted to the bdev.
+
+A new API `spdk_bdev_get_current_qd` was added to measure and return the queue depth from a
+bdev. This API is available even when queue depth sampling is disabled.
+
+Added `spdk_bdev_seek_data`, `spdk_bdev_seek_hole` and `spdk_bdev_io_get_seek_offset` functions
+that start from a given offset and seek for next data or for next hole. At this time only
+supported by lvol bdev module.
+
+A new parameter `io_drain_timeout` has been added to `spdk_bdev` structure. It controls how long
+a bdev reset must wait for IO to complete prior to issuing a reset to the underlying device.
+If there is no outstanding IO at the end of that period, the reset is skipped.
+Best defined for bdevs that share an underlying bdev, such as multiple lvol bdevs sharing
+an nvme device, to avoid unnecessarily resetting the underlying bdev and affecting other
+bdevs that are sharing it.
+Modifying this field is optional. Setting the value to 0 keeps the original behavior
+to always send resets immediately, even if there is no I/O outstanding.
+
+### blobstore
+
+Reserve space for `used_clusters` bitmap. The reserved space could be used for blobstore growing
+in the future.
+
+Added `is_zeroes` operation to `spdk_bs_dev`. It allows to detect if logical blocks are backed
+by zeroes device and do a shortcut in copy-on-write flow by excluding copy part from zeroes device.
+
+Added `spdk_blob_get_next_allocated_io_unit` and `spdk_blob_get_next_unallocated_io_unit` functions
+that start from a given offset and seek for first io_unit belonging to an allocated cluster
+or first io_unit belonging to an unallocated cluster.
+
+Added `spdk_bs_grow` function to grow blobstore size if the underlying bdev size is increased.
+This is used by lvol bdev via `bdev_lvol_grow_lvstore` RPC.
+
+### daos
+
+Added new DAOS bdev module, that creates SPDK block device on top of DAOS DFS.
+Please see [documentation](https://spdk.io/doc/bdev.html#bdev_config_daos) for more details.
+
+### env
+
+Added `spdk_pci_register_device_provider` and matching `SPDK_PCI_REGISTER_DEVICE_PROVIDER`
+functions for registering PCI device providers. That allow the VMD driver to be notified
+when users want to attach a device under a given BDF and when a device is detached.
+
+### init
+
+`spdk_subsystem_init_from_json_config` now fails if the JSON configuration file is not
+an object with an array named "subsystems".
+
+### iscsi
+
+Added `bdev_iscsi_set_options` RPC to modify options of the iSCSI bdev module.
+
+### json
+
+Added `spdk_json_find` API return errcode: EPROTOTYPE - json not enclosed in {}.
+`spdk_json_find` now returns -EPROTOTYPE instead of -ENOENT if the object parameter
+does not point to a JSON object (i.e. is not enclosed with {}).
+
+### lvol
+
+Add `num_md_pages_per_cluster_ratio` parameter to the `bdev_lvol_create_lvstore` RPC.
+Calculate `num_md_pages` from `num_md_pages_per_cluster_ratio`, and pass it to `spdk_bs_opts`.
+
+### nvme
+
+Added SPDK_NVME_TRANSPORT_CUSTOM_FABRICS to enum `spdk_nvme_transport_type` to support custom
+fabric transport. SPDK_NVME_TRANSPORT_CUSTOM was intended to be non-fabric custom transport.
+
+Added a new function `spdk_nvme_ns_cmd_verify` to submit a Verify Command to a Namespace.
+
+Added `spdk_nvme_ctrlr_disable_read_changed_ns_list_log_page` to allow an application to
+tell the driver to not read the CHANGED_NS_LIST log page in response to a NS_ATTR_CHANGED
+AEN.  When called the application is required to read this log page instead to clear the
+AEN.
+
+Added `psk` field to `spdk_nvme_ctrlr_opts` struct in order to enable SSL socket implementation
+of TCP connection and set the PSK. Applicable for TCP transport only.
+
+### raid
+
+Renamed the `raid5` module to `raid5f` to reflect that it is not a traditional
+RAID5 implementation - only full stripe writes are supported, partial stripe
+writes (read-modify-write) are not.
+
+### rpc
+
+Added `psk` parameter to `bdev_nvme_attach_controller` RPC in order to enable SSL socket implementation
+of TCP connection and set the PSK. Applicable for TCP transport only.
+
+New options `enable_ktls` and `tls_version` were added to the `sock_impl_set_options` structure.
+New options `psk_key` and `psk_identity` were added to the `sock_impl_set_options` structure.
+
+Added warning message for `bdev_rbd_create`, if it is used without -c.
+`bdev_rbd_create()` API without specifying -c is deprecated and will be removed in future release.
+
+Renamed `enable_vmd` RPC to `vmd_enable` to make it consistent with our naming scheme of
+`<subsystem>_<action>`.  For now, the old name is still available, but is marked as deprecated.
+
+New function `spdk_rpc_get_method_state_mask` was added to RPC library.
+
+### sma
+
+Extended `VolumeParameters` with crypto parameters allowing the user to configure crypto when
+attaching a volume to a device.  This interface is now supported by all upstream device types
+(nvmf-tcp, virtio-blk, vfio-user) using `bdev_crypto`.  Users must specify the crypto engine to use
+under `crypto` section in config.  It is also possible to register out-of-tree crypto engines by
+inheriting from the `CryptoEngine` class.
+
+Added two new methods: `SetQos` and `GetQosCapabilities` allowing the user to configure QoS on a
+per-device or per-volume level.  Not all QoS settings have to be supported by each device, so users
+can use `GetQosCapabilities` to query them for that.  All upstream device types support QoS on a
+per-volume level using bdev layer's QoS mechanism.
+
+### sock
+
+Added new `ssl` based socket implementation, the code is located in `module/sock/posix`.
+For now we are using hard-coded PSK and only support TLS 1.3.
+
+### util
+
+Added new functions: `spdk_hexlify` and `spdk_unhexlify`.
+
+A new API `spdk_xor_gen` was added to generate XOR from multiple source buffers. It is going to be
+used by `raid5f` for calculating parity.
+
+### vfu_tgt
+
+Added vfu_tgt library abstraction based on libvfio-user for PCI device emulation.
+Besides the NVMe device emulation, its now possible to emulate virtio-blk and virtio-scsi
+devices.
+
+### virtio
+
+virtio-vhost-user no longer tries to support dynamic memory allocation.  The vhost target does
+not support the high rate of SET_MEM_TABLE vhost messages that result from dynamic memory
+allocation, so a virtio-vhost-user device will now present an ERRLOG, assert, and skip the
+SET_MEM_TABLE vhost message if a memory notification is received outside of the normal device
+start/stop. Applications using the virtio library in vhost-user mode should now pre-allocate
+the application's memory using the -s/--mem-size option and use single shared memory file
+segments using the -g/--single-file-segments option.
+
+Added `vfio-user` transport type for virtio-blk and virtio-scsi devices.
 
 ### vmd
 
-(#2413) Reset root port config before enumeration.
+Fixed hotplug when a device is inserted in a slot in which a disk was already enumerated previously.
+Added two new RPCs: `vmd_remove_device` simulating a hotremove, and `vmd_rescan`, which rescans all
+buses managed by the VMD driver and hotplugs all newfound devices.
 
-(#2451) Use `config_bus_number` when resetting root ports
+## v22.05
 
-## v22.01: NVMe multipath, NVMe TCP zero-copy, NVMe-oF discovery service
+### sock
+
+A new option `ack_timeout` was added to the `spdk_sock_opts` structure.
+
+### util
+
+A new parameter `bounce_iovcnt` was added to `spdk_dif_generate_copy` and `spdk_dif_verify_copy`.
+The `bounce_iovcnt` is used to specify the number of bounce_iov to support multiple block-aligned
+fragment copies.
+
+A new API `spdk_copy_iovs_to_buf` and `spdk_copy_buf_to_iovs` were added to copy iovs to buf or
+copy buf to iovs. There're many cases need to use these two APIs.
+
+### bdev
+
+Removed deprecated spdk_bdev_module_finish_done(). Use spdk_bdev_module_fini_done() instead.
+
+A new API `spdk_bdev_unregister_by_name` was added to handle race conditions correctly.
+
+New APIs, `spdk_for_each_bdev` and `spdk_for_each_bdev_leaf`, were added to provide iteration
+safe for race conditions.
+
+A new RPC `bdev_nvme_get_io_paths` was added to get all active I/O paths.
+
+A new RPC `bdev_nvme_set_preferred_path` was added to set preferred I/O path for an NVMe bdev
+when in multipath mode. This RPC does not support NVMe bdevs in failover mode.
+
+A new RPC `bdev_nvme_set_multipath_policy` was added to set multipath policy of a NVMe bdev
+in multipath mode.
+
+A new option `disable_auto_failback` was added to the `bdev_nvme_set_options` RPC to disable
+automatic failback.
+
+### idxd / dsa
+
+A new parameter `flags` was added to all low level submission and preparation
+APIs to enable the caller to pass operation flags per the DSA specification.
+
+A new flag 'SPDK_IDXD_FLAG_PERSISTENT' was added to let DSA know that
+the destination is persistent.
+
+The RPC `idxd_scan_accel_engine` has been renamed to `dsa_scan_accel_engine`
+
+The RPC `iaa_scan_accel_engine` has been added.
+
+Many HW related structs/functions with the name `idxd` have been renamed `dsa`
+to more accurately represent the HW they are associated with.
+
+Two new functions were added to the library `spdk_idxd_submit_compress` and
+`spdk_idxd_submit_decompress`
+
+### accel_fw
+
+A new parameter `flags` was added to accel API.
+The APIs include:
+`spdk_accel_submit_copy`
+`spdk_accel_submit_dualcast`
+`spdk_accel_submit_fill`
+`spdk_accel_submit_copy_crc32c`
+`spdk_accel_submit_copy_crc32cv`
+`spdk_accel_submit_compress`
+`spdk_accel_submit_decompress`
+
+A new flag `ACCEL_FLAG_PERSISTENT` was added to indicate the target memory is PMEM.
+
+The API `spdk_accel_get_capabilities` has been removed.
+
+### crypto
+
+Support for AES_XTS was added for MLX5 polled mode driver (pmd).
+
+bdev_crypto_create RPC now requires hexlified 'key' and 'key2' params for all pmd drivers.
+Unhexlifying is performed during RPC command processing and the vbdev crypto module runs on
+binary keys as before.
+
+### bdev
+
+Added a timeout option to the `bdev_get_bdevs` RPC.  It allows the user to specify the amount of
+time to wait until a bdev with a given name appears in the system.
+
+### bdev_nvme
+
+Added `bdev_nvme_add_error_injection` and `bdev_nvme_remove_error_injection` RPCs to add and
+remove NVMe error injections.
+
+New parameters, `ctrlr_loss_timeout_sec`, `reconnect_delay_sec`, and `fast_io_fail_timeout_sec`, are
+added to the RPC `bdev_nvme_set_options`. They can be overridden if they are given by the RPC
+`bdev_nvme_attach_controller`.
+
+### blobstore
+
+New functions `spdk_blob_io_writev_ext` and `spdk_blob_io_readv_ext` are added. The new functions accept
+`spdk_blob_ext_io_opts` structure with extended IO request options.
+
+### event
+
+Added `msg_mempool_size` parameter to `spdk_reactors_init` and `spdk_thread_lib_init_ext`.
+The size of `g_spdk_msg_mempool` can now be controlled through the same-named
+user option of `spdk_app_opts` structure.
+
+### nvme
+
+The API `spdk_nvme_ctrlr_prepare_for_reset()` was deprecated. The functionality provided by the
+`spdk_nvme_ctrlr_prepare_for_reset()` was merged into the API `spdk_nvme_ctrlr_disconnect()`.
+
+### nvmf
+
+Removed deprecated max_qpairs_per_ctrlr parameter from nvmf_create_transport RPC. Use
+max_io_qpairs_per_ctrlr instead.
+
+Deprecated the ability for hosts to connect to the discovery subsystem automatically on any
+existing listener. Users should now explicitly add listeners for the discovery subsystem.
+Host can still connect to the discovery subsystem as before, but a warning message will be
+emitted if no listener was configured for the transport ID of the incoming connection.
+
+Added adaptive interrupt feature for vfio-user transport. New parameter `disable_adaptive_irq`
+is added to the RPC `nvmf_create_transport`.
+
+### thread
+
+Added `spdk_thread_exec_msg()` API.
+
+### scheduler
+
+`framework_set_scheduler` can now be called after application initialization.
+Added callbacks to set custom parameters specific for each scheduler implementation
+and `framework_get_scheduler` to retrieve them.
+
+Added `dynamic` scheduler options: load_limit, core_limit, core_busy. Their descriptions
+are available in JSON-RPC document, in section
+[framework_set_scheduler](jsonrpc.html#rpc_framework_set_scheduler).
+
+### raid
+
+Add concat as a special raid module. The concat module could create a virtual bdev.  The
+virtual bdev combines multiple underlying bdevs together. The layout of the underlying
+bdevs is one after another. The concat bdev is extendable. When the free space of the
+concat bdev is not enough, the user can deconstruct the concat bdev, then reconstruct it
+with an additional underlying bdev.
+
+### sock
+
+Allow MSG_ZEROCOPY flag to be set or not according to data size, which can be enabled and
+set by setting "zerocopy_threshold". zerocopy_threshold = 0 means disable this function;
+zerocopy_threshold > 0 means enable it and use this value as the threshold.
+
+### rpc
+
+Introduced `zerocopy_threshold` to enable zerocopy on send for server sockets according to
+data size to be flushed.
+
+## v22.01
 
 ### accel
 
@@ -165,6 +721,11 @@ individual traces.
 Added `spdk_ioviter_first` and `spdk_ioviter_next` to iterate over two iovecs and
 yield pointers to common length segments.
 
+### sock
+
+A new parameter `hint` is added to `spdk_sock_get_optimal_sock_group`. It allows to suggest
+a poll group when no optimal poll group is found.
+
 ## v21.10
 
 Structure `spdk_nvmf_target_opts` has been extended with new member `discovery_filter` which allows to specify
@@ -642,6 +1203,8 @@ Updated OCF submodule to v20.12.2
 
 Added `bdev_ocf_set_cache_mode` RPC to dynamically switch cache mode of OCF bdev.
 
+OCF deprecation notice has removed as Huawei is picking up support for the OCF project.
+
 ### opal
 
 Removed the `spdk_opal_supported` API.
@@ -1702,7 +2265,7 @@ A new `spdk_bdev_open_ext` function has been added and `spdk_bdev_open` function
 The new open function introduces requirement to provide callback function that will be called by
 asynchronous event such as bdev removal. `spdk_bdev_open_ext` function takes bdev name as
 an argument instead of bdev structure to avoid a race condition that can happen when the bdev
-is being removed between a call to get its structure based on a name and actually openning it.
+is being removed between a call to get its structure based on a name and actually opening it.
 
 New 'resize' event has been added to notify about change of block count property of block device.
 Event is delivered only if block device was opened with `spdk_bdev_open_ext` function.
@@ -2628,7 +3191,7 @@ Net framework initialization and finish is now done asynchronously.
 
 Added `spdk_rpc_is_method_allowed` function for checking whether method is permitted in a given state.
 Added `spdk_rpc_get_state` to check current state of RPC server.
-RPC `wait_subsystem_init` has been added to allow clients to block untill all subsystems are initialized.
+RPC `wait_subsystem_init` has been added to allow clients to block until all subsystems are initialized.
 
 ### json rpc
 
@@ -2926,7 +3489,7 @@ to link only the minimal set of components required.
 ### git pre-commit and pre-push hooks
 
 The pre-commit hook will run `scripts/check_format.sh` and verify there are no
-formating errors before allowing `git commit` to run. The pre-push hook runs
+formatting errors before allowing `git commit` to run. The pre-push hook runs
 `make CONFIG_WERROR=y` with and without `CONFIG_DEBUG=y` using both the gcc and
 clang compiler before allowing `git push` to run. Following each DEBUG build
 `test/unit/unittest.sh` is run and verified. Results are recorded in the

CODE_OF_CONDUCT.md

@@ -0,0 +1,130 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+SPDK core [maintainers](https://spdk.io/development/) are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+SPDK core maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported privately to any of the SPDK core maintainers. All complaints will be
+reviewed and investigated promptly and fairly.
+
+All SPDK core maintainers are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+SPDK core maintainers will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from SPDK core maintainers, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq

CONFIG

@@ -1,43 +1,21 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  All rights reserved.
-#  Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#  Copyright (c) 2021, 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
+#  Copyright (c) 2022 Dell Inc, or its subsidiaries.
-#  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.
 #
 
+# configure options: __CONFIGURE_OPTIONS__
+
 # Installation prefix
 CONFIG_PREFIX="/usr/local"
 
 # Target architecture
 CONFIG_ARCH=native
 
+# Destination directory for the libraries
+CONFIG_LIBDIR=
+
 # Prefix for cross compilation
 CONFIG_CROSS_PREFIX=
 
@@ -115,6 +93,7 @@ CONFIG_FIO_SOURCE_DIR=/usr/src/fio
 CONFIG_RDMA=n
 CONFIG_RDMA_SEND_WITH_INVAL=n
 CONFIG_RDMA_SET_ACK_TIMEOUT=n
+CONFIG_RDMA_SET_TOS=n
 CONFIG_RDMA_PROV=verbs
 
 # Enable NVMe Character Devices.
@@ -129,6 +108,14 @@ CONFIG_FC_PATH=
 # Requires librbd development libraries
 CONFIG_RBD=n
 
+# Build DAOS support in bdev modules
+# Requires daos development libraries
+CONFIG_DAOS=n
+CONFIG_DAOS_DIR=
+
+# Build UBLK support
+CONFIG_UBLK=n
+
 # Build vhost library.
 CONFIG_VHOST=y
 
@@ -139,15 +126,20 @@ CONFIG_VIRTIO=y
 CONFIG_VFIO_USER=n
 CONFIG_VFIO_USER_DIR=
 
-# Build with PMDK backends
+# Build with xNVMe
-CONFIG_PMDK=n
+CONFIG_XNVME=n
-CONFIG_PMDK_DIR=
 
-# Enable the dependencies for building the compress vbdev
+# Enable the dependencies for building the DPDK accel compress module
-CONFIG_REDUCE=n
+CONFIG_DPDK_COMPRESSDEV=n
 
-# Enable mlx5_pci dpdk compress PMD, enabled automatically if CONFIG_REDUCE=y and libmlx5 exists
+# Enable the dependencies for building the compress vbdev, includes the reduce library
-CONFIG_REDUCE_MLX5=n
+CONFIG_VBDEV_COMPRESS=n
+
+# Enable mlx5_pci dpdk compress PMD, enabled automatically if CONFIG_VBDEV_COMPRESS=y and libmlx5 exists
+CONFIG_VBDEV_COMPRESS_MLX5=n
+
+# Enable mlx5_pci dpdk crypto PMD, enabled automatically if CONFIG_CRYPTO=y and libmlx5 exists
+CONFIG_CRYPTO_MLX5=n
 
 # Requires libiscsi development libraries.
 CONFIG_ISCSI_INITIATOR=n
@@ -158,7 +150,7 @@ CONFIG_CRYPTO=n
 # Build spdk shared libraries in addition to the static ones.
 CONFIG_SHARED=n
 
-# Build with VTune suport.
+# Build with VTune support.
 CONFIG_VTUNE=n
 CONFIG_VTUNE_DIR=
 
@@ -173,17 +165,26 @@ CONFIG_CUSTOMOCF=n
 # Build ISA-L library
 CONFIG_ISAL=y
 
+# Build ISA-L-crypto library
+CONFIG_ISAL_CRYPTO=y
+
 # Build with IO_URING support
 CONFIG_URING=n
 
+# Build IO_URING bdev with ZNS support
+CONFIG_URING_ZNS=n
+
 # Path to custom built IO_URING library
 CONFIG_URING_PATH=
 
+# Path to custom built OPENSSL library
+CONFIG_OPENSSL_PATH=
+
 # Build with FUSE support
 CONFIG_FUSE=n
 
-# Build with RAID5 support
+# Build with RAID5f support
-CONFIG_RAID5=n
+CONFIG_RAID5F=n
 
 # Build with IDXD support
 # In this mode, SPDK fully controls the DSA device.
@@ -195,3 +196,27 @@ CONFIG_USDT=n
 # Build with IDXD kernel support.
 # In this mode, SPDK shares the DSA device with the kernel.
 CONFIG_IDXD_KERNEL=n
+
+# arc4random is available in stdlib.h
+CONFIG_HAVE_ARC4RANDOM=n
+
+# uuid_generate_sha1 is available in uuid/uuid.h
+CONFIG_HAVE_UUID_GENERATE_SHA1=n
+
+# Is DPDK using libbsd?
+CONFIG_HAVE_LIBBSD=n
+
+# Is DPDK using libarchive?
+CONFIG_HAVE_LIBARCHIVE=n
+
+# Path to IPSEC_MB used by DPDK
+CONFIG_IPSEC_MB_DIR=
+
+# Generate Storage Management Agent's protobuf interface
+CONFIG_SMA=n
+
+# Build with Avahi support
+CONFIG_AVAHI=n
+
+# Setup DPDK's RTE_MAX_LCORES
+CONFIG_MAX_LCORES=

Dockerfile.dapper

@@ -1,17 +0,0 @@
-FROM ubuntu:20.04
-
-ARG http_proxy
-ARG https_proxy
-
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN apt-get update && \
-    apt-get dist-upgrade -y && \
-    apt-get install -y make linux-libc-dev pkg-config \
-        devscripts libaio-dev libc6-dev gcc meson \
-	python3-pyelftools uuid-dev libssl-dev \
-	libibverbs-dev libfuse-dev libiscsi-dev \
-	zlib1g-dev libfdt-dev libpcap0.8-dev \
-	libncurses-dev libcunit1-dev \
-	build-essential nasm autoconf libtool automake
-

LICENSE

@@ -1,6 +1,5 @@
 The SPDK repo contains multiple git submodules each with its own
-license info. Unless otherwise noted all other code in this repo
+license info.
-is BSD as stated below.
 
 Submodule license info:
 dpdk: see dpdk/license
@@ -9,35 +8,23 @@ isa-l: see isa-l/LICENSE
 libvfio-user: see libvfio-user/LICENSE
 ocf: see ocf/LICENSE
 
-The rest of the SPDK repo:
+The rest of the SPDK repository uses the Open Source BSD-3-Clause
+license.  SPDK also uses SPDX Unique License Identifiers to eliminate
+the need to copy the license text into each individual file.
 
-BSD LICENSE
+Any new file contributions to SPDK shall adhere to the BSD-3-Clause
+license and use SPDX identifiers. Exceptions are subject to usual
+review and must be listed in this file.
 
-Copyright (c) Intel Corporation.
+Exceptions:
-All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
+* include/linux/* header files are BSD-3-Clause but do not use SPDX
-modification, are permitted provided that the following conditions
+  identifier to keep them identical to the same header files in the
-are met:
+  Linux kernel source tree.
 
-  * Redistributions of source code must retain the above copyright
+* include/spdk/tree.h and include/spdk/queue_extras are BSD-2-Clause,
-    notice, this list of conditions and the following disclaimer.
+  since there were primarily imported from FreeBSD.  tree.h uses an SPDX
-  * Redistributions in binary form must reproduce the above copyright
+  identifier but also the license text to reduce differences from the
-    notice, this list of conditions and the following disclaimer in
+  FreeBSD source tree.
-    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
+* lib/util/base64_neon.c is BSD-2-Clause.
-"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.

Makefile

@@ -1,36 +1,9 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  Copyright (c) 2020, Mellanox Corporation.
+#  Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES
 #  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.
-#
 
 S :=
 
@@ -46,7 +19,10 @@ DIRS-$(CONFIG_APPS) += app
 DIRS-y += test
 DIRS-$(CONFIG_IPSEC_MB) += ipsecbuild
 DIRS-$(CONFIG_ISAL) += isalbuild
+DIRS-$(CONFIG_ISAL_CRYPTO) += isalcryptobuild
 DIRS-$(CONFIG_VFIO_USER) += vfiouserbuild
+DIRS-$(CONFIG_SMA) += proto
+DIRS-$(CONFIG_XNVME) += xnvmebuild
 
 .PHONY: all clean $(DIRS-y) include/spdk/config.h mk/config.mk \
 	cc_version cxx_version .libs_only_other .ldflags ldflags install \
@@ -85,8 +61,13 @@ DPDK_DEPS += ipsecbuild
 endif
 
 ifeq ($(CONFIG_ISAL),y)
+ISALBUILD = isalbuild
 LIB += isalbuild
 DPDK_DEPS += isalbuild
+ifeq ($(CONFIG_ISAL_CRYPTO),y)
+ISALCRYPTOBUILD = isalcryptobuild
+LIB += isalcryptobuild
+endif
 endif
 
 ifeq ($(CONFIG_VFIO_USER),y)
@@ -94,6 +75,11 @@ VFIOUSERBUILD = vfiouserbuild
 LIB += vfiouserbuild
 endif
 
+ifeq ($(CONFIG_XNVME),y)
+XNVMEBUILD = xnvmebuild
+LIB += xnvmebuild
+endif
+
 all: mk/cc.mk $(DIRS-y)
 clean: $(DIRS-y)
 	$(Q)rm -f include/spdk/config.h
@@ -110,7 +96,7 @@ dpdkdeps $(DPDK_DEPS): $(WPDK)
 dpdkbuild: $(WPDK) $(DPDK_DEPS)
 endif
 
-lib: $(WPDK) $(DPDKBUILD) $(VFIOUSERBUILD)
+lib: $(WPDK) $(DPDKBUILD) $(VFIOUSERBUILD) $(XNVMEBUILD) $(ISALBUILD) $(ISALCRYPTOBUILD)
 module: lib
 shared_lib: module
 app: $(LIB)

README.md

@@ -2,6 +2,11 @@
 
 [![Build Status](https://travis-ci.org/spdk/spdk.svg?branch=master)](https://travis-ci.org/spdk/spdk)
 
+NOTE: The SPDK mailing list has moved to a new location. Please visit
+[this URL](https://lists.linuxfoundation.org/mailman/listinfo/spdk) to subscribe
+at the new location. Subscribers from the old location will not be automatically
+migrated to the new location.
+
 The Storage Performance Development Kit ([SPDK](http://www.spdk.io)) provides a set of tools
 and libraries for writing high performance, scalable, user-mode storage
 applications. It achieves high performance by moving all of the necessary

SECURITY.md

@@ -0,0 +1,4 @@
+# Security Policy
+
+The SPDK community has a documented CVE process [here](https://spdk.io/cve_threat/) that describes
+both how to report a potential security issue as well as who to contact for more information.

app/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -37,7 +9,6 @@ include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 DIRS-y += trace
 DIRS-y += trace_record
 DIRS-y += nvmf_tgt
-DIRS-y += iscsi_top
 DIRS-y += iscsi_tgt
 DIRS-y += spdk_tgt
 DIRS-y += spdk_lspci

app/iscsi_tgt/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2016 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -54,3 +26,9 @@ SPDK_LIB_LIST += event_nbd
 endif
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/iscsi_tgt/iscsi_tgt.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2016 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"

app/iscsi_top/.gitignore

@@ -1 +0,0 @@
-iscsi_top

app/iscsi_top/Makefile

@@ -1,46 +0,0 @@
-#
-#  BSD LICENSE
-#
-#  Copyright (c) Intel Corporation.
-#  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.
-#
-
-SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
-include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
-include $(SPDK_ROOT_DIR)/mk/spdk.modules.mk
-
-APP = iscsi_top
-
-SPDK_LIB_LIST = rpc
-
-CFLAGS += -I$(SPDK_ROOT_DIR)/lib
-
-C_SRCS := iscsi_top.c
-
-include $(SPDK_ROOT_DIR)/mk/spdk.app.mk

app/iscsi_top/iscsi_top.c

@@ -1,277 +0,0 @@
-/*-
- *   BSD LICENSE
- *
- *   Copyright (c) Intel Corporation.
- *   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.
- */
-
-#include "spdk/stdinc.h"
-
-#include "spdk/event.h"
-#include "spdk/jsonrpc.h"
-#include "spdk/rpc.h"
-#include "spdk/string.h"
-#include "spdk/trace.h"
-#include "spdk/util.h"
-
-#include "iscsi/conn.h"
-
-static char *exe_name;
-static int g_shm_id = 0;
-
-struct spdk_jsonrpc_client *g_rpc_client;
-
-static void usage(void)
-{
-	fprintf(stderr, "usage:\n");
-	fprintf(stderr, "   %s <option>\n", exe_name);
-	fprintf(stderr, "        option = '-i' to specify the shared memory ID,"
-		" (required)\n");
-	fprintf(stderr, " -r <path>  RPC listen address (default: /var/tmp/spdk.sock\n");
-}
-
-struct rpc_conn_info {
-	uint32_t	id;
-	uint32_t	cid;
-	uint32_t	tsih;
-	uint32_t	lcore_id;
-	char		*initiator_addr;
-	char		*target_addr;
-	char		*target_node_name;
-};
-
-static struct rpc_conn_info g_conn_info[1024];
-
-static const struct spdk_json_object_decoder rpc_conn_info_decoders[] = {
-	{"id", offsetof(struct rpc_conn_info, id), spdk_json_decode_uint32},
-	{"cid", offsetof(struct rpc_conn_info, cid), spdk_json_decode_uint32},
-	{"tsih", offsetof(struct rpc_conn_info, tsih), spdk_json_decode_uint32},
-	{"lcore_id", offsetof(struct rpc_conn_info, lcore_id), spdk_json_decode_uint32},
-	{"initiator_addr", offsetof(struct rpc_conn_info, initiator_addr), spdk_json_decode_string},
-	{"target_addr", offsetof(struct rpc_conn_info, target_addr), spdk_json_decode_string},
-	{"target_node_name", offsetof(struct rpc_conn_info, target_node_name), spdk_json_decode_string},
-};
-
-static int
-rpc_decode_conn_object(const struct spdk_json_val *val, void *out)
-{
-	struct rpc_conn_info *info = (struct rpc_conn_info *)out;
-
-	return spdk_json_decode_object(val, rpc_conn_info_decoders,
-				       SPDK_COUNTOF(rpc_conn_info_decoders), info);
-}
-
-static void
-print_connections(void)
-{
-	struct spdk_jsonrpc_client_response *json_resp = NULL;
-	struct spdk_json_write_ctx *w;
-	struct spdk_jsonrpc_client_request *request;
-	int rc;
-	size_t conn_count, i;
-	struct rpc_conn_info *conn;
-
-	request = spdk_jsonrpc_client_create_request();
-	if (request == NULL) {
-		return;
-	}
-
-	w = spdk_jsonrpc_begin_request(request, 1, "iscsi_get_connections");
-	spdk_jsonrpc_end_request(request, w);
-	spdk_jsonrpc_client_send_request(g_rpc_client, request);
-
-	do {
-		rc = spdk_jsonrpc_client_poll(g_rpc_client, 1);
-	} while (rc == 0 || rc == -ENOTCONN);
-
-	if (rc <= 0) {
-		goto end;
-	}
-
-	json_resp = spdk_jsonrpc_client_get_response(g_rpc_client);
-	if (json_resp == NULL) {
-		goto end;
-	}
-
-	if (spdk_json_decode_array(json_resp->result, rpc_decode_conn_object, g_conn_info,
-				   SPDK_COUNTOF(g_conn_info), &conn_count, sizeof(struct rpc_conn_info))) {
-		goto end;
-	}
-
-	for (i = 0; i < conn_count; i++) {
-		conn = &g_conn_info[i];
-
-		printf("Connection: %u CID: %u TSIH: %u Initiator Address: %s Target Address: %s Target Node Name: %s\n",
-		       conn->id, conn->cid, conn->tsih, conn->initiator_addr, conn->target_addr, conn->target_node_name);
-	}
-
-end:
-	spdk_jsonrpc_client_free_request(request);
-}
-
-int main(int argc, char **argv)
-{
-	void			*history_ptr;
-	struct spdk_trace_histories *histories;
-	struct spdk_trace_history *history;
-	const char *rpc_socket_path = SPDK_DEFAULT_RPC_ADDR;
-
-	uint64_t		tasks_done, last_tasks_done[SPDK_TRACE_MAX_LCORE];
-	int			delay, old_delay, history_fd, i, quit, rc;
-	int			tasks_done_delta, tasks_done_per_sec;
-	int			total_tasks_done_per_sec;
-	struct timeval		timeout;
-	fd_set			fds;
-	char			ch;
-	struct termios		oldt, newt;
-	char			spdk_trace_shm_name[64];
-	int			op;
-
-	exe_name = argv[0];
-	while ((op = getopt(argc, argv, "i:r:")) != -1) {
-		switch (op) {
-		case 'i':
-			g_shm_id = spdk_strtol(optarg, 10);
-			break;
-		case 'r':
-			rpc_socket_path = optarg;
-			break;
-		default:
-			usage();
-			exit(1);
-		}
-	}
-
-	g_rpc_client = spdk_jsonrpc_client_connect(rpc_socket_path, AF_UNIX);
-	if (!g_rpc_client) {
-		fprintf(stderr, "spdk_jsonrpc_client_connect() failed: %d\n", errno);
-		return 1;
-	}
-
-	snprintf(spdk_trace_shm_name, sizeof(spdk_trace_shm_name), "/iscsi_trace.%d", g_shm_id);
-	history_fd = shm_open(spdk_trace_shm_name, O_RDONLY, 0600);
-	if (history_fd < 0) {
-		fprintf(stderr, "Unable to open history shm %s\n", spdk_trace_shm_name);
-		usage();
-		exit(1);
-	}
-
-	history_ptr = mmap(NULL, sizeof(*histories), PROT_READ, MAP_SHARED, history_fd, 0);
-	if (history_ptr == MAP_FAILED) {
-		fprintf(stderr, "Unable to mmap history shm (%d).\n", errno);
-		exit(1);
-	}
-
-	histories = (struct spdk_trace_histories *)history_ptr;
-
-	memset(last_tasks_done, 0, sizeof(last_tasks_done));
-
-	for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
-		history = spdk_get_per_lcore_history(histories, i);
-		last_tasks_done[i] = history->tpoint_count[TRACE_ISCSI_TASK_DONE];
-	}
-
-	delay = 1;
-	quit = 0;
-
-	tcgetattr(0, &oldt);
-	newt = oldt;
-	newt.c_lflag &= ~(ICANON);
-	tcsetattr(0, TCSANOW, &newt);
-
-	while (1) {
-
-		FD_ZERO(&fds);
-		FD_SET(0, &fds);
-		timeout.tv_sec = delay;
-		timeout.tv_usec = 0;
-		rc = select(2, &fds, NULL, NULL, &timeout);
-
-		if (rc > 0) {
-			if (read(0, &ch, 1) != 1) {
-				fprintf(stderr, "Read error on stdin\n");
-				goto cleanup;
-			}
-
-			printf("\b");
-			switch (ch) {
-			case 'd':
-				printf("Enter num seconds to delay (1-10): ");
-				old_delay = delay;
-				rc = scanf("%d", &delay);
-				if (rc != 1) {
-					fprintf(stderr, "Illegal delay value\n");
-					delay = old_delay;
-				} else if (delay < 1 || delay > 10) {
-					delay = 1;
-				}
-				break;
-			case 'q':
-				quit = 1;
-				break;
-			default:
-				fprintf(stderr, "'%c' not recognized\n", ch);
-				break;
-			}
-
-			if (quit == 1) {
-				break;
-			}
-		}
-
-		printf("\e[1;1H\e[2J");
-		print_connections();
-		printf("lcore   tasks\n");
-		printf("=============\n");
-		total_tasks_done_per_sec = 0;
-		for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
-			history = spdk_get_per_lcore_history(histories, i);
-			tasks_done = history->tpoint_count[TRACE_ISCSI_TASK_DONE];
-			tasks_done_delta = tasks_done - last_tasks_done[i];
-			if (tasks_done_delta == 0) {
-				continue;
-			}
-			last_tasks_done[i] = tasks_done;
-			tasks_done_per_sec = tasks_done_delta / delay;
-			printf("%5d %7d\n", history->lcore, tasks_done_per_sec);
-			total_tasks_done_per_sec += tasks_done_per_sec;
-		}
-		printf("Total %7d\n", total_tasks_done_per_sec);
-	}
-
-cleanup:
-	tcsetattr(0, TCSANOW, &oldt);
-
-	munmap(history_ptr, sizeof(*histories));
-	close(history_fd);
-
-	spdk_jsonrpc_client_close(g_rpc_client);
-
-	return (0);
-}

app/nvmf_tgt/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2016 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -50,3 +22,9 @@ SPDK_LIB_LIST += event_nbd
 endif
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/nvmf_tgt/nvmf_main.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2017 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"

app/spdk_dd/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2017 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -42,3 +14,9 @@ C_SRCS := spdk_dd.c
 SPDK_LIB_LIST = $(ALL_MODULES_LIST) event event_bdev
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/spdk_dd/spdk_dd.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2020 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"
@@ -46,8 +18,8 @@
 #include <liburing.h>
 #endif
 
-#define DD_NSEC_SINCE_X(time_now, time_x) ((1000000000 * time_now.tv_sec + time_now.tv_nsec) \
+#define TIMESPEC_TO_MS(time) ((time.tv_sec * 1000) + (time.tv_nsec / 1000000))
-											- (1000000000 * time_x.tv_sec + time_x.tv_nsec))
+#define STATUS_POLLER_PERIOD_SEC 1
 
 struct spdk_dd_opts {
 	char		*input_file;
@@ -62,6 +34,7 @@ struct spdk_dd_opts {
 	int64_t		io_unit_count;
 	uint32_t	queue_depth;
 	bool		aio;
+	bool		sparse;
 };
 
 static struct spdk_dd_opts g_opts = {
@@ -81,9 +54,10 @@ struct dd_io {
 	struct iocb		iocb;
 	enum dd_submit_type	type;
 #ifdef SPDK_CONFIG_URING
-	struct iovec		iov;
+	int			idx;
 #endif
 	void			*buf;
+	STAILQ_ENTRY(dd_io)	link;
 };
 
 enum dd_target_type {
@@ -104,14 +78,11 @@ struct dd_target {
 #ifdef SPDK_CONFIG_URING
 		struct {
 			int fd;
-			struct io_uring ring;
+			int idx;
-			struct spdk_poller *poller;
 		} uring;
 #endif
 		struct {
 			int fd;
-			io_context_t io_ctx;
-			struct spdk_poller *poller;
 		} aio;
 	} u;
 
@@ -133,8 +104,28 @@ struct dd_job {
 
 	struct dd_io		*ios;
 
+	union {
+#ifdef SPDK_CONFIG_URING
+		struct {
+			struct io_uring ring;
+			bool active;
+			struct spdk_poller *poller;
+		} uring;
+#endif
+		struct {
+			io_context_t io_ctx;
+			struct spdk_poller *poller;
+		} aio;
+	} u;
+
 	uint32_t		outstanding;
 	uint64_t		copy_size;
+	STAILQ_HEAD(, dd_io)	seek_queue;
+
+	struct timespec		start_time;
+	uint64_t		total_bytes;
+	uint64_t		incremental_bytes;
+	struct spdk_poller	*status_poller;
 };
 
 struct dd_flags {
@@ -157,10 +148,23 @@ static struct dd_flags g_flags[] = {
 
 static struct dd_job g_job = {};
 static int g_error = 0;
-static struct timespec g_start_time;
 static bool g_interrupt;
 
-static void dd_target_populate_buffer(struct dd_io *io);
+static void dd_target_seek(struct dd_io *io);
+static void _dd_bdev_seek_hole_done(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg);
+
+static void
+dd_cleanup_bdev(struct dd_target io)
+{
+	/* This can be only on the error path.
+	 * To prevent the SEGV, need add checks here.
+	 */
+	if (io.u.bdev.ch) {
+		spdk_put_io_channel(io.u.bdev.ch);
+	}
+
+	spdk_bdev_close(io.u.bdev.desc);
+}
 
 static void
 dd_exit(int rc)
@@ -168,68 +172,80 @@ dd_exit(int rc)
 	if (g_job.input.type == DD_TARGET_TYPE_FILE) {
 #ifdef SPDK_CONFIG_URING
 		if (g_opts.aio == false) {
-			spdk_poller_unregister(&g_job.input.u.uring.poller);
 			close(g_job.input.u.uring.fd);
 		} else
 #endif
 		{
-			spdk_poller_unregister(&g_job.input.u.aio.poller);
-			io_destroy(g_job.input.u.aio.io_ctx);
 			close(g_job.input.u.aio.fd);
 		}
 	} else if (g_job.input.type == DD_TARGET_TYPE_BDEV && g_job.input.open) {
-		spdk_put_io_channel(g_job.input.u.bdev.ch);
+		dd_cleanup_bdev(g_job.input);
-		spdk_bdev_close(g_job.input.u.bdev.desc);
 	}
 
 	if (g_job.output.type == DD_TARGET_TYPE_FILE) {
 #ifdef SPDK_CONFIG_URING
 		if (g_opts.aio == false) {
-			spdk_poller_unregister(&g_job.output.u.uring.poller);
 			close(g_job.output.u.uring.fd);
 		} else
 #endif
 		{
-			spdk_poller_unregister(&g_job.output.u.aio.poller);
-			io_destroy(g_job.output.u.aio.io_ctx);
 			close(g_job.output.u.aio.fd);
 		}
 	} else if (g_job.output.type == DD_TARGET_TYPE_BDEV && g_job.output.open) {
-		spdk_put_io_channel(g_job.output.u.bdev.ch);
+		dd_cleanup_bdev(g_job.output);
-		spdk_bdev_close(g_job.output.u.bdev.desc);
 	}
 
+	if (g_job.input.type == DD_TARGET_TYPE_FILE || g_job.output.type == DD_TARGET_TYPE_FILE) {
+#ifdef SPDK_CONFIG_URING
+		if (g_opts.aio == false) {
+			spdk_poller_unregister(&g_job.u.uring.poller);
+		} else
+#endif
+		{
+			spdk_poller_unregister(&g_job.u.aio.poller);
+		}
+	}
+
+	spdk_poller_unregister(&g_job.status_poller);
+
 	spdk_app_stop(rc);
 }
 
 static void
-dd_show_progress(uint64_t offset, uint64_t length, bool finish)
+dd_show_progress(bool finish)
 {
 	char *unit_str[5] = {"", "k", "M", "G", "T"};
 	char *speed_type_str[2] = {"", "average "};
 	char *size_unit_str = "";
 	char *speed_unit_str = "";
 	char *speed_type = "";
-	uint64_t size = g_job.copy_size;
 	uint64_t size_unit = 1;
 	uint64_t speed_unit = 1;
 	uint64_t speed, tmp_speed;
-	static struct timespec g_time_last = {.tv_nsec = 0};
-	static uint64_t g_data_last = 0;
-	struct timespec time_now;
 	int i = 0;
+	uint64_t milliseconds;
+	uint64_t size, tmp_size;
 
-	clock_gettime(CLOCK_REALTIME, &time_now);
+	size = g_job.incremental_bytes;
 
-	if (((time_now.tv_sec == g_time_last.tv_sec && offset + length != g_job.copy_size) ||
+	g_job.incremental_bytes = 0;
-	     (offset < g_data_last)) && !finish) {
+	g_job.total_bytes += size;
-		/* refresh every one second */
+
-		return;
+	if (finish) {
+		struct timespec time_now;
+
+		clock_gettime(CLOCK_REALTIME, &time_now);
+
+		milliseconds = spdk_max(1, TIMESPEC_TO_MS(time_now) - TIMESPEC_TO_MS(g_job.start_time));
+		size = g_job.total_bytes;
+	} else {
+		milliseconds = STATUS_POLLER_PERIOD_SEC * 1000;
 	}
 
 	/* Find the right unit for size displaying (B vs kB vs MB vs GB vs TB) */
-	while (size > 1024 * 10) {
+	tmp_size = size;
-		size >>= 10;
+	while (tmp_size > 1024 * 10) {
+		tmp_size >>= 10;
 		size_unit <<= 10;
 		size_unit_str = unit_str[++i];
 		if (i == 4) {
@@ -237,18 +253,14 @@ dd_show_progress(uint64_t offset, uint64_t length, bool finish)
 		}
 	}
 
-	if (!finish) {
+	speed_type = finish ? speed_type_str[1] : speed_type_str[0];
-		speed_type = speed_type_str[0];
+	speed = (size * 1000) / milliseconds;
-		tmp_speed = speed = (offset - g_data_last) * 1000000000 / DD_NSEC_SINCE_X(time_now, g_time_last);
-	} else {
-		speed_type = speed_type_str[1];
-		tmp_speed = speed = offset * 1000000000 / DD_NSEC_SINCE_X(time_now, g_start_time);
-	}
 
 	i = 0;
 
 	/* Find the right unit for speed displaying (Bps vs kBps vs MBps vs GBps vs TBps) */
-	while (tmp_speed > 1024) {
+	tmp_speed = speed;
+	while (tmp_speed > 1024 * 10) {
 		tmp_speed >>= 10;
 		speed_unit <<= 10;
 		speed_unit_str = unit_str[++i];
@@ -258,12 +270,47 @@ dd_show_progress(uint64_t offset, uint64_t length, bool finish)
 	}
 
 	printf("\33[2K\rCopying: %" PRIu64 "/%" PRIu64 " [%sB] (%s%" PRIu64 " %sBps)",
-	       (offset + length) / size_unit, g_job.copy_size / size_unit, size_unit_str, speed_type,
+	       g_job.total_bytes / size_unit, g_job.copy_size / size_unit, size_unit_str, speed_type,
 	       speed / speed_unit, speed_unit_str);
 	fflush(stdout);
+}
 
-	g_data_last = offset;
+static int
-	g_time_last = time_now;
+dd_status_poller(void *ctx)
+{
+	dd_show_progress(false);
+	return SPDK_POLLER_BUSY;
+}
+
+static void
+dd_finalize_output(void)
+{
+	off_t curr_offset;
+	int rc = 0;
+
+	if (g_job.outstanding > 0) {
+		return;
+	}
+
+	if (g_opts.output_file) {
+		curr_offset = lseek(g_job.output.u.aio.fd, 0, SEEK_END);
+		if (curr_offset == (off_t) -1) {
+			SPDK_ERRLOG("Could not seek output file for finalize: %s\n", strerror(errno));
+			g_error = errno;
+		} else if ((uint64_t)curr_offset < g_job.copy_size + g_job.output.pos) {
+			rc = ftruncate(g_job.output.u.aio.fd, g_job.copy_size + g_job.output.pos);
+			if (rc != 0) {
+				SPDK_ERRLOG("Could not truncate output file for finalize: %s\n", strerror(errno));
+				g_error = errno;
+			}
+		}
+	}
+
+	if (g_error == 0) {
+		dd_show_progress(true);
+		printf("\n\n");
+	}
+	dd_exit(g_error);
 }
 
 #ifdef SPDK_CONFIG_URING
@@ -272,16 +319,15 @@ dd_uring_submit(struct dd_io *io, struct dd_target *target, uint64_t length, uin
 {
 	struct io_uring_sqe *sqe;
 
-	io->iov.iov_base = io->buf;
+	sqe = io_uring_get_sqe(&g_job.u.uring.ring);
-	io->iov.iov_len = length;
-	sqe = io_uring_get_sqe(&target->u.uring.ring);
 	if (io->type == DD_READ || io->type == DD_POPULATE) {
-		io_uring_prep_readv(sqe, target->u.uring.fd, &io->iov, 1, offset);
+		io_uring_prep_read_fixed(sqe, target->u.uring.idx, io->buf, length, offset, io->idx);
 	} else {
-		io_uring_prep_writev(sqe, target->u.uring.fd, &io->iov, 1, offset);
+		io_uring_prep_write_fixed(sqe, target->u.uring.idx, io->buf, length, offset, io->idx);
 	}
+	sqe->flags |= IOSQE_FIXED_FILE;
 	io_uring_sqe_set_data(sqe, io);
-	io_uring_submit(&target->u.uring.ring);
+	io_uring_submit(&g_job.u.uring.ring);
 }
 #endif
 
@@ -295,7 +341,7 @@ _dd_write_bdev_done(struct spdk_bdev_io *bdev_io,
 	assert(g_job.outstanding > 0);
 	g_job.outstanding--;
 	spdk_bdev_free_io(bdev_io);
-	dd_target_populate_buffer(io);
+	dd_target_seek(io);
 }
 
 static void
@@ -312,7 +358,7 @@ dd_target_write(struct dd_io *io)
 	if (g_error != 0 || g_interrupt == true) {
 		if (g_job.outstanding == 0) {
 			if (g_error == 0) {
-				dd_show_progress(io->offset, io->length, true);
+				dd_show_progress(true);
 				printf("\n\n");
 			}
 			dd_exit(g_error);
@@ -320,8 +366,7 @@ dd_target_write(struct dd_io *io)
 		return;
 	}
 
-	dd_show_progress(read_offset, io->length, false);
+	g_job.incremental_bytes += io->length;
-
 	g_job.outstanding++;
 	io->type = DD_WRITE;
 
@@ -336,7 +381,7 @@ dd_target_write(struct dd_io *io)
 
 			io_prep_pwrite(iocb, target->u.aio.fd, io->buf, length, write_offset);
 			iocb->data = io;
-			if (io_submit(target->u.aio.io_ctx, 1, &iocb) < 0) {
+			if (io_submit(g_job.u.aio.io_ctx, 1, &iocb) < 0) {
 				rc = -errno;
 			}
 		}
@@ -398,7 +443,7 @@ dd_target_read(struct dd_io *io)
 
 			io_prep_pread(iocb, target->u.aio.fd, io->buf, io->length, io->offset);
 			iocb->data = io;
-			if (io_submit(target->u.aio.io_ctx, 1, &iocb) < 0) {
+			if (io_submit(g_job.u.aio.io_ctx, 1, &iocb) < 0) {
 				rc = -errno;
 			}
 		}
@@ -444,12 +489,12 @@ dd_target_populate_buffer(struct dd_io *io)
 	int rc = 0;
 
 	io->offset = g_job.input.pos;
-	io->length = spdk_min((uint64_t)g_opts.io_unit_size, g_job.copy_size - read_offset);
+	io->length = spdk_min(io->length, g_job.copy_size - read_offset);
 
 	if (io->length == 0 || g_error != 0 || g_interrupt == true) {
 		if (g_job.outstanding == 0) {
 			if (g_error == 0) {
-				dd_show_progress(read_offset, io->length, true);
+				dd_show_progress(true);
 				printf("\n\n");
 			}
 			dd_exit(g_error);
@@ -481,7 +526,7 @@ dd_target_populate_buffer(struct dd_io *io)
 
 			io_prep_pread(iocb, target->u.aio.fd, io->buf, length, write_offset);
 			iocb->data = io;
-			if (io_submit(target->u.aio.io_ctx, 1, &iocb) < 0) {
+			if (io_submit(g_job.u.aio.io_ctx, 1, &iocb) < 0) {
 				rc = -errno;
 			}
 		}
@@ -502,6 +547,235 @@ dd_target_populate_buffer(struct dd_io *io)
 	}
 }
 
+static off_t
+dd_file_seek_data(void)
+{
+	off_t next_data_offset = (off_t) -1;
+
+	next_data_offset = lseek(g_job.input.u.aio.fd, g_job.input.pos, SEEK_DATA);
+
+	if (next_data_offset == (off_t) -1) {
+		/* NXIO with SEEK_DATA means there are no more data to read.
+		 * But in case of input and output files, we may have to finalize output file
+		 * inserting a hole to the end of the file.
+		 */
+		if (errno == ENXIO) {
+			dd_finalize_output();
+		} else if (g_job.outstanding == 0) {
+			SPDK_ERRLOG("Could not seek input file for data: %s\n", strerror(errno));
+			g_error = errno;
+			dd_exit(g_error);
+		}
+	}
+
+	return next_data_offset;
+}
+
+static off_t
+dd_file_seek_hole(void)
+{
+	off_t next_hole_offset = (off_t) -1;
+
+	next_hole_offset = lseek(g_job.input.u.aio.fd, g_job.input.pos, SEEK_HOLE);
+
+	if (next_hole_offset == (off_t) -1 && g_job.outstanding == 0) {
+		SPDK_ERRLOG("Could not seek input file for hole: %s\n", strerror(errno));
+		g_error = errno;
+		dd_exit(g_error);
+	}
+
+	return next_hole_offset;
+}
+
+static void
+_dd_bdev_seek_data_done(struct spdk_bdev_io *bdev_io,
+			bool success,
+			void *cb_arg)
+{
+	struct dd_io *io = cb_arg;
+	uint64_t next_data_offset_blocks = UINT64_MAX;
+	struct dd_target *target = &g_job.input;
+	int rc = 0;
+
+	if (g_error != 0 || g_interrupt == true) {
+		STAILQ_REMOVE_HEAD(&g_job.seek_queue, link);
+		if (g_job.outstanding == 0) {
+			if (g_error == 0) {
+				dd_show_progress(true);
+				printf("\n\n");
+			}
+			dd_exit(g_error);
+		}
+		return;
+	}
+
+	assert(g_job.outstanding > 0);
+	g_job.outstanding--;
+
+	next_data_offset_blocks = spdk_bdev_io_get_seek_offset(bdev_io);
+	spdk_bdev_free_io(bdev_io);
+
+	/* UINT64_MAX means there are no more data to read.
+	 * But in case of input and output files, we may have to finalize output file
+	 * inserting a hole to the end of the file.
+	 */
+	if (next_data_offset_blocks == UINT64_MAX) {
+		STAILQ_REMOVE_HEAD(&g_job.seek_queue, link);
+		dd_finalize_output();
+		return;
+	}
+
+	g_job.input.pos = next_data_offset_blocks * g_job.input.block_size;
+
+	g_job.outstanding++;
+	rc = spdk_bdev_seek_hole(target->u.bdev.desc, target->u.bdev.ch,
+				 g_job.input.pos / g_job.input.block_size,
+				 _dd_bdev_seek_hole_done, io);
+
+	if (rc != 0) {
+		SPDK_ERRLOG("%s\n", strerror(-rc));
+		STAILQ_REMOVE_HEAD(&g_job.seek_queue, link);
+		assert(g_job.outstanding > 0);
+		g_job.outstanding--;
+		g_error = rc;
+		if (g_job.outstanding == 0) {
+			dd_exit(rc);
+		}
+	}
+}
+
+static void
+_dd_bdev_seek_hole_done(struct spdk_bdev_io *bdev_io,
+			bool success,
+			void *cb_arg)
+{
+	struct dd_io *io = cb_arg;
+	struct dd_target *target = &g_job.input;
+	uint64_t next_hole_offset_blocks = UINT64_MAX;
+	struct dd_io *seek_io;
+	int rc = 0;
+
+	/* First seek operation is the one in progress, i.e. this one just ended */
+	STAILQ_REMOVE_HEAD(&g_job.seek_queue, link);
+
+	if (g_error != 0 || g_interrupt == true) {
+		if (g_job.outstanding == 0) {
+			if (g_error == 0) {
+				dd_show_progress(true);
+				printf("\n\n");
+			}
+			dd_exit(g_error);
+		}
+		return;
+	}
+
+	assert(g_job.outstanding > 0);
+	g_job.outstanding--;
+
+	next_hole_offset_blocks = spdk_bdev_io_get_seek_offset(bdev_io);
+	spdk_bdev_free_io(bdev_io);
+
+	/* UINT64_MAX means there are no more holes. */
+	if (next_hole_offset_blocks == UINT64_MAX) {
+		io->length = g_opts.io_unit_size;
+	} else {
+		io->length = spdk_min((uint64_t)g_opts.io_unit_size,
+				      next_hole_offset_blocks * g_job.input.block_size - g_job.input.pos);
+	}
+
+	dd_target_populate_buffer(io);
+
+	/* If input reading is not at the end, start following seek operation in the queue */
+	if (!STAILQ_EMPTY(&g_job.seek_queue) && g_job.input.pos < g_job.input.total_size) {
+		seek_io = STAILQ_FIRST(&g_job.seek_queue);
+		assert(seek_io != NULL);
+		g_job.outstanding++;
+		rc = spdk_bdev_seek_data(target->u.bdev.desc, target->u.bdev.ch,
+					 g_job.input.pos / g_job.input.block_size,
+					 _dd_bdev_seek_data_done, seek_io);
+
+		if (rc != 0) {
+			SPDK_ERRLOG("%s\n", strerror(-rc));
+			assert(g_job.outstanding > 0);
+			g_job.outstanding--;
+			g_error = rc;
+			if (g_job.outstanding == 0) {
+				dd_exit(rc);
+			}
+		}
+	}
+}
+
+static void
+dd_target_seek(struct dd_io *io)
+{
+	struct dd_target *target = &g_job.input;
+	uint64_t read_region_start = g_opts.input_offset * g_opts.io_unit_size;
+	uint64_t read_offset = g_job.input.pos - read_region_start;
+	off_t next_data_offset = (off_t) -1;
+	off_t next_hole_offset = (off_t) -1;
+	int rc = 0;
+
+	if (!g_opts.sparse) {
+		dd_target_populate_buffer(io);
+		return;
+	}
+
+	if (g_job.copy_size - read_offset == 0 || g_error != 0 || g_interrupt == true) {
+		if (g_job.outstanding == 0) {
+			if (g_error == 0) {
+				dd_show_progress(true);
+				printf("\n\n");
+			}
+			dd_exit(g_error);
+		}
+		return;
+	}
+
+	if (target->type == DD_TARGET_TYPE_FILE) {
+		next_data_offset = dd_file_seek_data();
+		if (next_data_offset < 0) {
+			return;
+		} else if ((uint64_t)next_data_offset > g_job.input.pos) {
+			g_job.input.pos = next_data_offset;
+		}
+
+		next_hole_offset = dd_file_seek_hole();
+		if (next_hole_offset < 0) {
+			return;
+		} else if ((uint64_t)next_hole_offset > g_job.input.pos) {
+			io->length = spdk_min((uint64_t)g_opts.io_unit_size,
+					      (uint64_t)(next_hole_offset - g_job.input.pos));
+		} else {
+			io->length = g_opts.io_unit_size;
+		}
+
+		dd_target_populate_buffer(io);
+	} else if (target->type == DD_TARGET_TYPE_BDEV) {
+		/* Check if other seek operation is in progress */
+		if (STAILQ_EMPTY(&g_job.seek_queue)) {
+			g_job.outstanding++;
+			rc = spdk_bdev_seek_data(target->u.bdev.desc, target->u.bdev.ch,
+						 g_job.input.pos / g_job.input.block_size,
+						 _dd_bdev_seek_data_done, io);
+
+		}
+
+		STAILQ_INSERT_TAIL(&g_job.seek_queue, io, link);
+	}
+
+	if (rc != 0) {
+		SPDK_ERRLOG("%s\n", strerror(-rc));
+		assert(g_job.outstanding > 0);
+		g_job.outstanding--;
+		g_error = rc;
+		if (g_job.outstanding == 0) {
+			dd_exit(rc);
+		}
+		return;
+	}
+}
+
 static void
 dd_complete_poll(struct dd_io *io)
 {
@@ -516,7 +790,7 @@ dd_complete_poll(struct dd_io *io)
 		dd_target_write(io);
 		break;
 	case DD_WRITE:
-		dd_target_populate_buffer(io);
+		dd_target_seek(io);
 		break;
 	default:
 		assert(false);
@@ -528,14 +802,13 @@ dd_complete_poll(struct dd_io *io)
 static int
 dd_uring_poll(void *ctx)
 {
-	struct dd_target *target = ctx;
 	struct io_uring_cqe *cqe;
 	struct dd_io *io;
 	int rc = 0;
 	int i;
 
 	for (i = 0; i < (int)g_opts.queue_depth; i++) {
-		rc = io_uring_peek_cqe(&target->u.uring.ring, &cqe);
+		rc = io_uring_peek_cqe(&g_job.u.uring.ring, &cqe);
 		if (rc == 0) {
 			if (cqe->res == -EAGAIN) {
 				continue;
@@ -545,7 +818,7 @@ dd_uring_poll(void *ctx)
 			}
 
 			io = io_uring_cqe_get_data(cqe);
-			io_uring_cqe_seen(&target->u.uring.ring, cqe);
+			io_uring_cqe_seen(&g_job.u.uring.ring, cqe);
 
 			dd_complete_poll(io);
 		} else if (rc != - EAGAIN) {
@@ -559,7 +832,7 @@ dd_uring_poll(void *ctx)
 #endif
 
 static int
-dd_aio_poll(io_context_t io_ctx)
+dd_aio_poll(void *ctx)
 {
 	struct io_event events[32];
 	int rc = 0;
@@ -570,7 +843,7 @@ dd_aio_poll(io_context_t io_ctx)
 	timeout.tv_sec = 0;
 	timeout.tv_nsec = 0;
 
-	rc = io_getevents(io_ctx, 0, 32, events, &timeout);
+	rc = io_getevents(g_job.u.aio.io_ctx, 0, 32, events, &timeout);
 
 	if (rc < 0) {
 		SPDK_ERRLOG("%s\n", strerror(-rc));
@@ -589,36 +862,6 @@ dd_aio_poll(io_context_t io_ctx)
 	return rc;
 }
 
-static int
-dd_input_poll(void *ctx)
-{
-	int rc = 0;
-
-	assert(g_job.input.type == DD_TARGET_TYPE_FILE);
-
-	rc = dd_aio_poll(g_job.input.u.aio.io_ctx);
-	if (rc == -ENOSPC) {
-		SPDK_ERRLOG("No more file content to read\n");
-	}
-
-	return rc;
-}
-
-static int
-dd_output_poll(void *ctx)
-{
-	int rc = 0;
-
-	assert(g_job.output.type == DD_TARGET_TYPE_FILE);
-
-	rc = dd_aio_poll(g_job.output.u.aio.io_ctx);
-	if (rc == -ENOSPC) {
-		SPDK_ERRLOG("No space left on device\n");
-	}
-
-	return rc;
-}
-
 static int
 dd_open_file(struct dd_target *target, const char *fname, int flags, uint64_t skip_blocks,
 	     bool input)
@@ -644,14 +887,6 @@ dd_open_file(struct dd_target *target, const char *fname, int flags, uint64_t sk
 		flags |= O_TRUNC;
 	}
 
-#ifdef SPDK_CONFIG_URING
-	/* io_uring does not work correctly with O_NONBLOCK flag */
-	if (flags & O_NONBLOCK && g_opts.aio == false) {
-		flags &= ~O_NONBLOCK;
-		SPDK_WARNLOG("Skipping 'nonblock' flag due to existing issue with uring implementation and this flag\n");
-	}
-#endif
-
 	target->type = DD_TARGET_TYPE_FILE;
 	*fd = open(fname, flags, 0600);
 	if (*fd < 0) {
@@ -660,7 +895,11 @@ dd_open_file(struct dd_target *target, const char *fname, int flags, uint64_t sk
 	}
 
 	target->block_size = spdk_max(spdk_fd_get_blocklen(*fd), 1);
+
 	target->total_size = spdk_fd_get_size(*fd);
+	if (target->total_size == 0) {
+		target->total_size = g_opts.io_unit_size * g_opts.io_unit_count;
+	}
 
 	if (input == true) {
 		g_opts.queue_depth = spdk_min(g_opts.queue_depth,
@@ -671,16 +910,7 @@ dd_open_file(struct dd_target *target, const char *fname, int flags, uint64_t sk
 		g_opts.queue_depth = spdk_min(g_opts.queue_depth, g_opts.io_unit_count);
 	}
 
-#ifdef SPDK_CONFIG_URING
+	return 0;
-	if (g_opts.aio == false) {
-		io_uring_queue_init(g_opts.queue_depth, &target->u.uring.ring, 0);
-		target->open = true;
-		return 0;
-	} else
-#endif
-	{
-		return io_setup(g_opts.queue_depth, &target->u.aio.io_ctx);
-	}
 }
 
 static void
@@ -726,7 +956,8 @@ dd_open_bdev(struct dd_target *target, const char *bdev_name, uint64_t skip_bloc
 	return 0;
 }
 
-static void dd_finish(void)
+static void
+dd_finish(void)
 {
 	/* Interrupt operation */
 	g_interrupt = true;
@@ -761,6 +992,65 @@ parse_flags(char *file_flags)
 	return flags;
 }
 
+#ifdef SPDK_CONFIG_URING
+static bool
+dd_is_blk(int fd)
+{
+	struct stat st;
+
+	if (fstat(fd, &st) != 0) {
+		return false;
+	}
+
+	return S_ISBLK(st.st_mode);
+}
+
+static int
+dd_register_files(void)
+{
+	int fds[2];
+	unsigned count = 0;
+
+	if (g_opts.input_file) {
+		fds[count] = g_job.input.u.uring.fd;
+		g_job.input.u.uring.idx = count;
+		count++;
+	}
+
+	if (g_opts.output_file) {
+		fds[count] = g_job.output.u.uring.fd;
+		g_job.output.u.uring.idx = count;
+		count++;
+	}
+
+	return io_uring_register_files(&g_job.u.uring.ring, fds, count);
+
+}
+
+static int
+dd_register_buffers(void)
+{
+	struct iovec *iovs;
+	int i, rc;
+
+	iovs = calloc(g_opts.queue_depth, sizeof(struct iovec));
+	if (iovs == NULL) {
+		return -ENOMEM;
+	}
+
+	for (i = 0; i < (int)g_opts.queue_depth; i++) {
+		iovs[i].iov_base = g_job.ios[i].buf;
+		iovs[i].iov_len = g_opts.io_unit_size;
+		g_job.ios[i].idx = i;
+	}
+
+	rc = io_uring_register_buffers(&g_job.u.uring.ring, iovs, g_opts.queue_depth);
+
+	free(iovs);
+	return rc;
+}
+#endif
+
 static void
 dd_run(void *arg1)
 {
@@ -778,14 +1068,6 @@ dd_run(void *arg1)
 			dd_exit(-errno);
 			return;
 		}
-#ifdef SPDK_CONFIG_URING
-		if (g_opts.aio == false) {
-			g_job.input.u.uring.poller = spdk_poller_register(dd_uring_poll, &g_job.input, 0);
-		} else
-#endif
-		{
-			g_job.input.u.aio.poller = spdk_poller_register(dd_input_poll, NULL, 0);
-		}
 	} else if (g_opts.input_bdev) {
 		rc = dd_open_bdev(&g_job.input, g_opts.input_bdev, g_opts.input_offset);
 		if (rc < 0) {
@@ -835,14 +1117,6 @@ dd_run(void *arg1)
 			dd_exit(-errno);
 			return;
 		}
-#ifdef SPDK_CONFIG_URING
-		if (g_opts.aio == false) {
-			g_job.output.u.uring.poller = spdk_poller_register(dd_uring_poll, &g_job.output, 0);
-		} else
-#endif
-		{
-			g_job.output.u.aio.poller = spdk_poller_register(dd_output_poll, NULL, 0);
-		}
 	} else if (g_opts.output_bdev) {
 		rc = dd_open_bdev(&g_job.output, g_opts.output_bdev, g_opts.output_offset);
 		if (rc < 0) {
@@ -874,6 +1148,13 @@ dd_run(void *arg1)
 		return;
 	}
 
+	if (g_opts.input_bdev && g_opts.io_unit_size % g_job.input.block_size != 0) {
+		SPDK_ERRLOG("--bs value must be a multiple of input native block size (%d)\n",
+			    g_job.input.block_size);
+		dd_exit(-EINVAL);
+		return;
+	}
+
 	g_job.ios = calloc(g_opts.queue_depth, sizeof(struct dd_io));
 	if (g_job.ios == NULL) {
 		SPDK_ERRLOG("%s\n", strerror(ENOMEM));
@@ -888,12 +1169,63 @@ dd_run(void *arg1)
 			dd_exit(-ENOMEM);
 			return;
 		}
+		g_job.ios[i].length = (uint64_t)g_opts.io_unit_size;
 	}
 
-	clock_gettime(CLOCK_REALTIME, &g_start_time);
+	if (g_opts.input_file || g_opts.output_file) {
+#ifdef SPDK_CONFIG_URING
+		if (g_opts.aio == false) {
+			unsigned int io_uring_flags = IORING_SETUP_SQPOLL;
+			int flags = parse_flags(g_opts.input_file_flags) & parse_flags(g_opts.output_file_flags);
+
+			if ((flags & O_DIRECT) != 0 &&
+			    dd_is_blk(g_job.input.u.uring.fd) &&
+			    dd_is_blk(g_job.output.u.uring.fd)) {
+				io_uring_flags = IORING_SETUP_IOPOLL;
+			}
+
+			g_job.u.uring.poller = SPDK_POLLER_REGISTER(dd_uring_poll, NULL, 0);
+			rc = io_uring_queue_init(g_opts.queue_depth * 2, &g_job.u.uring.ring, io_uring_flags);
+			if (rc) {
+				SPDK_ERRLOG("Failed to create io_uring: %d (%s)\n", rc, spdk_strerror(-rc));
+				dd_exit(rc);
+				return;
+			}
+			g_job.u.uring.active = true;
+
+			/* Register the files */
+			rc = dd_register_files();
+			if (rc) {
+				SPDK_ERRLOG("Failed to register files with io_uring: %d (%s)\n", rc, spdk_strerror(-rc));
+				dd_exit(rc);
+				return;
+			}
+
+			/* Register the buffers */
+			rc = dd_register_buffers();
+			if (rc) {
+				SPDK_ERRLOG("Failed to register buffers with io_uring: %d (%s)\n", rc, spdk_strerror(-rc));
+				dd_exit(rc);
+				return;
+			}
+
+		} else
+#endif
+		{
+			g_job.u.aio.poller = SPDK_POLLER_REGISTER(dd_aio_poll, NULL, 0);
+			io_setup(g_opts.queue_depth, &g_job.u.aio.io_ctx);
+		}
+	}
+
+	clock_gettime(CLOCK_REALTIME, &g_job.start_time);
+
+	g_job.status_poller = SPDK_POLLER_REGISTER(dd_status_poller, NULL,
+			      STATUS_POLLER_PERIOD_SEC * SPDK_SEC_TO_USEC);
+
+	STAILQ_INIT(&g_job.seek_queue);
 
 	for (i = 0; i < g_opts.queue_depth; i++) {
-		dd_target_populate_buffer(&g_job.ios[i]);
+		dd_target_seek(&g_job.ios[i]);
 	}
 
 }
@@ -911,6 +1243,7 @@ enum dd_cmdline_opts {
 	DD_OPTION_QD,
 	DD_OPTION_COUNT,
 	DD_OPTION_AIO,
+	DD_OPTION_SPARSE,
 };
 
 static struct option g_cmdline_opts[] = {
@@ -986,6 +1319,12 @@ static struct option g_cmdline_opts[] = {
 		.flag = NULL,
 		.val = DD_OPTION_AIO,
 	},
+	{
+		.name = "sparse",
+		.has_arg = 0,
+		.flag = NULL,
+		.val = DD_OPTION_SPARSE,
+	},
 	{
 		.name = NULL
 	}
@@ -1007,6 +1346,7 @@ usage(void)
 	printf(" --skip Skip this many I/O units at start of input. (default: 0)\n");
 	printf(" --seek Skip this many I/O units at start of output. (default: 0)\n");
 	printf(" --aio Force usage of AIO. (by default io_uring is used if available)\n");
+	printf(" --sparse Enable hole skipping in input target\n");
 	printf(" Available iflag and oflag values:\n");
 	printf("  append - append mode\n");
 	printf("  direct - use direct I/O for data\n");
@@ -1059,6 +1399,9 @@ parse_args(int argc, char *argv)
 	case DD_OPTION_AIO:
 		g_opts.aio = true;
 		break;
+	case DD_OPTION_SPARSE:
+		g_opts.sparse = true;
+		break;
 	default:
 		usage();
 		return 1;
@@ -1078,17 +1421,20 @@ dd_free(void)
 	free(g_opts.input_file_flags);
 	free(g_opts.output_file_flags);
 
-#ifdef SPDK_CONFIG_URING
-	if (g_opts.aio == false) {
-		if (g_job.input.type == DD_TARGET_TYPE_FILE && g_job.input.open == true) {
-			io_uring_queue_exit(&g_job.input.u.uring.ring);
-		}
 
-		if (g_job.output.type == DD_TARGET_TYPE_FILE && g_job.output.open == true) {
+	if (g_job.input.type == DD_TARGET_TYPE_FILE || g_job.output.type == DD_TARGET_TYPE_FILE) {
-			io_uring_queue_exit(&g_job.output.u.uring.ring);
+#ifdef SPDK_CONFIG_URING
+		if (g_opts.aio == false) {
+			if (g_job.u.uring.active) {
+				io_uring_unregister_files(&g_job.u.uring.ring);
+				io_uring_queue_exit(&g_job.u.uring.ring);
+			}
+		} else
+#endif
+		{
+			io_destroy(g_job.u.aio.io_ctx);
 		}
 	}
-#endif
 
 	if (g_job.ios) {
 		for (i = 0; i < g_opts.queue_depth; i++) {

app/spdk_lspci/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -42,3 +14,9 @@ C_SRCS := spdk_lspci.c
 SPDK_LIB_LIST = $(SOCK_MODULES_LIST) nvme vmd
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/spdk_lspci/spdk_lspci.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2019 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"

app/spdk_tgt/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2018 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -41,8 +13,6 @@ C_SRCS := spdk_tgt.c
 
 SPDK_LIB_LIST = $(ALL_MODULES_LIST)
 
-SPDK_LIB_LIST += bdev_longhorn
-
 SPDK_LIB_LIST += event event_iscsi event_nvmf
 
 ifeq ($(SPDK_ROOT_DIR)/lib/env_dpdk,$(CONFIG_ENV))
@@ -51,8 +21,14 @@ endif
 
 ifeq ($(OS),Linux)
 SPDK_LIB_LIST += event_nbd
+ifeq ($(CONFIG_UBLK),y)
+SPDK_LIB_LIST += event_ublk
+endif
 ifeq ($(CONFIG_VHOST),y)
-SPDK_LIB_LIST += event_vhost
+SPDK_LIB_LIST += event_vhost_blk event_vhost_scsi
+endif
+ifeq ($(CONFIG_VFIO_USER),y)
+SPDK_LIB_LIST += event_vfu_tgt
 endif
 endif
 

app/spdk_tgt/spdk_tgt.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2018 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"

app/spdk_top/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -42,3 +14,9 @@ SPDK_LIB_LIST = rpc
 LIBS=-lpanel -lmenu -lncurses
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/trace/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -43,3 +15,9 @@ SPDK_LIB_LIST += json trace_parser
 CXX_SRCS := trace.cpp
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app_cxx.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/trace/trace.cpp

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2016 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"
@@ -68,6 +40,12 @@ extern "C" {
 	{
 		assert(false);
 	}
+
+	uint64_t
+	spdk_get_ticks(void)
+	{
+		return 0;
+	}
 } /* extern "C" */
 
 static void usage(void);
@@ -340,7 +318,8 @@ print_json(void *cb_ctx, const void *data, size_t size)
 	return 0;
 }
 
-static void usage(void)
+static void
+usage(void)
 {
 	fprintf(stderr, "usage:\n");
 	fprintf(stderr, "   %s <option> <lcore#>\n", g_exe_name);
@@ -357,7 +336,8 @@ static void usage(void)
 	fprintf(stderr, "                 '-j' to use JSON to format the output\n");
 }
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
 	struct spdk_trace_parser_opts	opts;
 	struct spdk_trace_parser_entry	entry;

app/trace_record/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -41,3 +13,9 @@ APP = spdk_trace_record
 C_SRCS := trace_record.c
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/trace_record/trace_record.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2018 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"
@@ -52,6 +24,7 @@ static uint64_t g_histories_size;
 struct lcore_trace_record_ctx {
 	char lcore_file[TRACE_PATH_MAX];
 	int fd;
+	bool valid;
 	struct spdk_trace_history *in_history;
 	struct spdk_trace_history *out_history;
 
@@ -122,11 +95,15 @@ input_trace_file_mmap(struct aggr_trace_record_ctx *ctx, const char *shm_name)
 
 	ctx->trace_histories = (struct spdk_trace_histories *)history_ptr;
 	for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
-		ctx->lcore_ports[i].in_history = spdk_get_per_lcore_history(ctx->trace_histories, i);
+		struct spdk_trace_history *history;
 
-		if (g_verbose) {
+		history = spdk_get_per_lcore_history(ctx->trace_histories, i);
+		ctx->lcore_ports[i].in_history = history;
+		ctx->lcore_ports[i].valid = (history != NULL);
+
+		if (g_verbose && history) {
 			printf("Number of trace entries for lcore (%d): %ju\n", i,
-			       ctx->lcore_ports[i].in_history->num_entries);
+			       history->num_entries);
 		}
 	}
 
@@ -177,6 +154,10 @@ output_trace_files_prepare(struct aggr_trace_record_ctx *ctx, const char *aggr_p
 	for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
 		port_ctx = &ctx->lcore_ports[i];
 
+		if (!port_ctx->valid) {
+			continue;
+		}
+
 		port_ctx->fd = open(port_ctx->lcore_file, flags, 0600);
 		if (port_ctx->fd < 0) {
 			fprintf(stderr, "Could not open lcore file %s.\n", port_ctx->lcore_file);
@@ -460,6 +441,7 @@ trace_files_aggregate(struct aggr_trace_record_ctx *ctx)
 	uint64_t lcore_offsets[SPDK_TRACE_MAX_LCORE + 1];
 	int rc, i;
 	ssize_t len = 0;
+	uint64_t current_offset;
 	uint64_t len_sum;
 
 	ctx->out_fd = open(ctx->out_file, flags, 0600);
@@ -481,11 +463,17 @@ trace_files_aggregate(struct aggr_trace_record_ctx *ctx)
 	}
 
 	/* Update and append lcore offsets converged trace file */
-	lcore_offsets[0] = sizeof(struct spdk_trace_flags);
+	current_offset = sizeof(struct spdk_trace_flags);
-	for (i = 1; i < (int)SPDK_COUNTOF(lcore_offsets); i++) {
+	for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
-		lcore_offsets[i] = spdk_get_trace_history_size(ctx->lcore_ports[i - 1].num_entries) +
+		lcore_port = &ctx->lcore_ports[i];
-				   lcore_offsets[i - 1];
+		if (lcore_port->valid) {
+			lcore_offsets[i] = current_offset;
+			current_offset += spdk_get_trace_history_size(lcore_port->num_entries);
+		} else {
+			lcore_offsets[i] = 0;
+		}
 	}
+	lcore_offsets[SPDK_TRACE_MAX_LCORE] = current_offset;
 
 	rc = cont_write(ctx->out_fd, lcore_offsets, sizeof(lcore_offsets));
 	if (rc < 0) {
@@ -497,6 +485,10 @@ trace_files_aggregate(struct aggr_trace_record_ctx *ctx)
 	for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
 		lcore_port = &ctx->lcore_ports[i];
 
+		if (!lcore_port->valid) {
+			continue;
+		}
+
 		lcore_port->out_history->num_entries = lcore_port->num_entries;
 		rc = cont_write(ctx->out_fd, lcore_port->out_history, sizeof(struct spdk_trace_history));
 		if (rc < 0) {
@@ -521,6 +513,9 @@ trace_files_aggregate(struct aggr_trace_record_ctx *ctx)
 			}
 		}
 
+		/* Clear rc so that the last cont_write() doesn't get interpreted as a failure. */
+		rc = 0;
+
 		if (len_sum != lcore_port->num_entries * sizeof(struct spdk_trace_entry)) {
 			fprintf(stderr, "Len of lcore trace file doesn't match number of entries for lcore\n");
 		}
@@ -566,7 +561,8 @@ setup_exit_signal_handler(void)
 	return rc;
 }
 
-static void usage(void)
+static void
+usage(void)
 {
 	printf("\n%s is used to record all SPDK generated trace entries\n", g_exe_name);
 	printf("from SPDK trace shared-memory to specified file.\n\n");
@@ -582,7 +578,8 @@ static void usage(void)
 	printf("                 '-h' to print usage information\n");
 }
 
-int main(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
 	const char			*app_name = NULL;
 	const char			*file_name = NULL;
@@ -665,6 +662,9 @@ int main(int argc, char **argv)
 		for (i = 0; i < SPDK_TRACE_MAX_LCORE; i++) {
 			lcore_port = &ctx.lcore_ports[i];
 
+			if (!lcore_port->valid) {
+				continue;
+			}
 			rc = lcore_trace_record(lcore_port);
 			if (rc) {
 				break;

app/vhost/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2017 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -39,10 +11,16 @@ APP = vhost
 
 C_SRCS := vhost.c
 
-SPDK_LIB_LIST = $(ALL_MODULES_LIST) event event_vhost event_nbd
+SPDK_LIB_LIST = $(ALL_MODULES_LIST) event event_vhost_blk event_vhost_scsi event_nbd
 
 ifeq ($(SPDK_ROOT_DIR)/lib/env_dpdk,$(CONFIG_ENV))
 SPDK_LIB_LIST += env_dpdk_rpc
 endif
 
 include $(SPDK_ROOT_DIR)/mk/spdk.app.mk
+
+install: $(APP)
+	$(INSTALL_APP)
+
+uninstall:
+	$(UNINSTALL_APP)

app/vhost/vhost.c

@@ -1,34 +1,6 @@
-/*-
+/*   SPDX-License-Identifier: BSD-3-Clause
- *   BSD LICENSE
+ *   Copyright (C) 2017 Intel Corporation.
- *
- *   Copyright (c) Intel Corporation.
  *   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.
  */
 
 #include "spdk/stdinc.h"

autobuild.sh

@@ -1,37 +1,14 @@
 #!/usr/bin/env bash
-
+#  SPDX-License-Identifier: BSD-3-Clause
-set -e
+#  Copyright (C) 2015 Intel Corporation
-
+#  All rights reserved.
-# If the configuration of tests is not provided, no tests will be carried out.
+#
-if [[ ! -f $1 ]]; then
-	echo "ERROR: SPDK test configuration not specified"
-	exit 1
-fi
 
 rootdir=$(readlink -f $(dirname $0))
 
-source "$1"
+source "$rootdir/test/common/autobuild_common.sh"
-source "$rootdir/test/common/autotest_common.sh"
-source "$rootdir/scripts/common.sh"
-
-if [[ -n $EXTERNAL_MAKE_HUGEMEM ]]; then
-	export EXTERNAL_MAKE_HUGEMEM
-fi
-
-out=$output_dir
-if [ -n "$SPDK_TEST_NATIVE_DPDK" ]; then
-	scanbuild_exclude=" --exclude $(dirname $SPDK_RUN_EXTERNAL_DPDK)"
-else
-	scanbuild_exclude="--exclude $rootdir/dpdk/"
-fi
-scanbuild="scan-build -o $output_dir/scan-build-tmp $scanbuild_exclude --status-bugs"
-config_params=$(get_config_params)
-
-trap '[[ -d $SPDK_WORKSPACE ]] && rm -rf "$SPDK_WORKSPACE"' 0
-
-SPDK_WORKSPACE=$(mktemp -dt "spdk_$(date +%s).XXXXXX")
-export SPDK_WORKSPACE
 
+SPDK_TEST_AUTOBUILD=${SPDK_TEST_AUTOBUILD:-}
 umask 022
 cd $rootdir
 
@@ -39,281 +16,6 @@ cd $rootdir
 date -u
 git describe --tags
 
-function ocf_precompile() {
-	# We compile OCF sources ourselves
-	# They don't need to be checked with scanbuild and code coverage is not applicable
-	# So we precompile OCF now for further use as standalone static library
-	./configure $(echo $config_params | sed 's/--enable-coverage//g')
-	$MAKE $MAKEFLAGS include/spdk/config.h
-	CC=gcc CCAR=ar $MAKE $MAKEFLAGS -C lib/env_ocf exportlib O=$rootdir/ocf.a
-	# Set config to use precompiled library
-	config_params="$config_params --with-ocf=/$rootdir/ocf.a"
-	# need to reconfigure to avoid clearing ocf related files on future make clean.
-	./configure $config_params
-}
-
-function build_native_dpdk() {
-	local external_dpdk_dir
-	local external_dpdk_base_dir
-	local compiler_version
-	local compiler
-	local dpdk_kmods
-
-	compiler=${CC:-gcc}
-
-	# Export CC to be absolutely sure it's set.
-	# If CC was not set and we defaulted to "gcc" then we need to do the export
-	# so that "meson build" command a few lines below is aware of which compiler
-	# to use.
-	export CC="$compiler"
-
-	if [[ $compiler != *clang* && $compiler != *gcc* ]]; then
-		echo "Unsupported compiler detected ($compiler), failing the test" >&2
-		return 1
-	fi
-
-	compiler_version=$("$compiler" -dumpversion)
-	compiler_version=${compiler_version%%.*}
-	external_dpdk_dir="$SPDK_RUN_EXTERNAL_DPDK"
-	external_dpdk_base_dir="$(dirname $external_dpdk_dir)"
-
-	if [[ ! -d "$external_dpdk_base_dir" ]]; then
-		sudo mkdir -p "$external_dpdk_base_dir"
-		sudo chown -R $(whoami) "$external_dpdk_base_dir"/..
-	fi
-	orgdir=$PWD
-
-	rm -rf "$external_dpdk_base_dir"
-	git clone --branch $SPDK_TEST_NATIVE_DPDK --depth 1 http://dpdk.org/git/dpdk "$external_dpdk_base_dir"
-	git -C "$external_dpdk_base_dir" log --oneline -n 5
-
-	dpdk_cflags="-fPIC -g -fcommon"
-	dpdk_ldflags=""
-	dpdk_ver=$(< "$external_dpdk_base_dir/VERSION")
-
-	if [[ $compiler == *gcc* && $compiler_version -ge 5 ]]; then
-		dpdk_cflags+=" -Werror"
-	fi
-
-	if [[ $compiler == *gcc* && $compiler_version -ge 10 ]]; then
-		dpdk_cflags+=" -Wno-stringop-overflow"
-	fi
-
-	# the drivers we use
-	# net/i40e driver is not really needed by us, but it's built as a workaround
-	# for DPDK issue: https://bugs.dpdk.org/show_bug.cgi?id=576
-	DPDK_DRIVERS=("bus" "bus/pci" "bus/vdev" "mempool/ring" "net/i40e" "net/i40e/base")
-
-	if [[ "$SPDK_TEST_CRYPTO" -eq 1 ]]; then
-		intel_ipsec_mb_ver=v0.54
-		intel_ipsec_mb_drv=crypto/aesni_mb
-		intel_ipsec_lib=""
-		if ge "$dpdk_ver" 21.11.0; then
-			# Minimum supported version of intel-ipsec-mb, for DPDK >= 21.11, is 1.0.
-			# Source of the aesni_mb driver was moved to ipsec_mb. .{h,so,a} were moved
-			# to ./lib.
-			# https://github.com/dpdk/dpdk/commit/918fd2f1466b0e3b21a033df7012a77a83665582.
-			intel_ipsec_mb_ver=v1.0
-			intel_ipsec_mb_drv=crypto/ipsec_mb
-			intel_ipsec_lib=lib
-		fi
-		git clone --branch "$intel_ipsec_mb_ver" --depth 1 https://github.com/intel/intel-ipsec-mb.git "$external_dpdk_base_dir/intel-ipsec-mb"
-		cd "$external_dpdk_base_dir/intel-ipsec-mb"
-		$MAKE $MAKEFLAGS all SHARED=y EXTRA_CFLAGS=-fPIC
-		DPDK_DRIVERS+=("crypto")
-		DPDK_DRIVERS+=("$intel_ipsec_mb_drv")
-		DPDK_DRIVERS+=("crypto/qat")
-		DPDK_DRIVERS+=("compress/qat")
-		DPDK_DRIVERS+=("common/qat")
-		dpdk_cflags+=" -I$external_dpdk_base_dir/intel-ipsec-mb/$intel_ipsec_lib"
-		dpdk_ldflags+=" -L$external_dpdk_base_dir/intel-ipsec-mb/$intel_ipsec_lib"
-		export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$external_dpdk_base_dir/intel-ipsec-mb/$intel_ipsec_lib"
-	fi
-
-	if [[ "$SPDK_TEST_REDUCE" -eq 1 ]]; then
-		isal_dir="$external_dpdk_base_dir/isa-l"
-		git clone --branch v2.29.0 --depth 1 https://github.com/intel/isa-l.git "$isal_dir"
-
-		cd $isal_dir
-		./autogen.sh
-		./configure CFLAGS="-fPIC -g -O2" --enable-shared=yes --prefix="$isal_dir/build"
-		ln -s $PWD/include $PWD/isa-l
-		$MAKE $MAKEFLAGS all
-		$MAKE install
-		DPDK_DRIVERS+=("compress")
-		DPDK_DRIVERS+=("compress/isal")
-		DPDK_DRIVERS+=("compress/qat")
-		DPDK_DRIVERS+=("common/qat")
-		if ge "$dpdk_ver" 21.02.0; then
-			# SPDK enables REDUCE_MLX in case supported version of DPDK is detected
-			# so make sure proper libs are built.
-			DPDK_DRIVERS+=("bus/auxiliary")
-			DPDK_DRIVERS+=("common/mlx5")
-			DPDK_DRIVERS+=("common/mlx5/linux")
-			DPDK_DRIVERS+=("compress/mlx5")
-		fi
-		export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$isal_dir/build/lib/pkgconfig"
-		export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:$isal_dir/build/lib"
-	fi
-
-	cd $external_dpdk_base_dir
-	if [ "$(uname -s)" = "Linux" ]; then
-		if lt $dpdk_ver 21.11.0; then
-			patch -p1 < "$rootdir/test/common/config/pkgdep/patches/dpdk/20.11/dpdk_pci.patch"
-			patch -p1 < "$rootdir/test/common/config/pkgdep/patches/dpdk/20.11/dpdk_qat.patch"
-		else
-			patch -p1 < "$rootdir/test/common/config/pkgdep/patches/dpdk/21.11+/dpdk_qat.patch"
-		fi
-	fi
-
-	dpdk_kmods="false"
-	if [ "$(uname -s)" = "FreeBSD" ]; then
-		dpdk_kmods="true"
-	fi
-
-	meson build-tmp --prefix="$external_dpdk_dir" --libdir lib \
-		-Denable_docs=false -Denable_kmods="$dpdk_kmods" -Dtests=false \
-		-Dc_link_args="$dpdk_ldflags" -Dc_args="$dpdk_cflags" \
-		-Dmachine=native -Denable_drivers=$(printf "%s," "${DPDK_DRIVERS[@]}")
-	ninja -C "$external_dpdk_base_dir/build-tmp" $MAKEFLAGS
-	ninja -C "$external_dpdk_base_dir/build-tmp" $MAKEFLAGS install
-
-	# Save this path. In tests are run using autorun.sh then autotest.sh
-	# script will be unaware of LD_LIBRARY_PATH and will fail tests.
-	echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH" > /tmp/spdk-ld-path
-
-	cd "$orgdir"
-}
-
-function make_fail_cleanup() {
-	if [ -d $out/scan-build-tmp ]; then
-		scanoutput=$(ls -1 $out/scan-build-tmp/)
-		mv $out/scan-build-tmp/$scanoutput $out/scan-build
-		rm -rf $out/scan-build-tmp
-		chmod -R a+rX $out/scan-build
-	fi
-	false
-}
-
-function scanbuild_make() {
-	pass=true
-	"$rootdir/configure" $config_params --without-shared
-	$scanbuild $MAKE $MAKEFLAGS > $out/build_output.txt && rm -rf $out/scan-build-tmp || make_fail_cleanup
-	xtrace_disable
-
-	rm -f $out/*files.txt
-	for ent in $(find app examples lib module test -type f | grep -vF ".h"); do
-		if [[ $ent == lib/env_ocf* ]]; then continue; fi
-		if file -bi $ent | grep -q 'text/x-c'; then
-			echo $ent | sed 's/\.cp\{0,2\}$//g' >> $out/all_c_files.txt
-		fi
-	done
-	xtrace_restore
-
-	grep -E "CC|CXX" $out/build_output.txt | sed 's/\s\s\(CC\|CXX\)\s//g' | sed 's/\.o//g' > $out/built_c_files.txt
-	cat $rootdir/test/common/skipped_build_files.txt >> $out/built_c_files.txt
-
-	sort -o $out/all_c_files.txt $out/all_c_files.txt
-	sort -o $out/built_c_files.txt $out/built_c_files.txt
-	# from comm manual:
-	#   -2 suppress column 2 (lines unique to FILE2)
-	#   -3 suppress column 3 (lines that appear in both files)
-	# comm may exit 1 if no lines were printed (undocumented, unreliable)
-	comm -2 -3 $out/all_c_files.txt $out/built_c_files.txt > $out/unbuilt_c_files.txt || true
-
-	if [ $(wc -l < $out/unbuilt_c_files.txt) -ge 1 ]; then
-		echo "missing files"
-		cat $out/unbuilt_c_files.txt
-		pass=false
-	fi
-
-	$pass
-}
-
-function porcelain_check() {
-	if [ $(git status --porcelain --ignore-submodules | wc -l) -ne 0 ]; then
-		echo "Generated files missing from .gitignore:"
-		git status --porcelain --ignore-submodules
-		exit 1
-	fi
-}
-
-# Check that header file dependencies are working correctly by
-#  capturing a binary's stat data before and after touching a
-#  header file and re-making.
-function header_dependency_check() {
-	STAT1=$(stat $SPDK_BIN_DIR/spdk_tgt)
-	sleep 1
-	touch lib/nvme/nvme_internal.h
-	$MAKE $MAKEFLAGS
-	STAT2=$(stat $SPDK_BIN_DIR/spdk_tgt)
-
-	if [ "$STAT1" == "$STAT2" ]; then
-		echo "Header dependency check failed"
-		false
-	fi
-}
-
-function test_make_uninstall() {
-	# Create empty file to check if it is not deleted by target uninstall
-	touch "$SPDK_WORKSPACE/usr/lib/sample_xyz.a"
-	$MAKE $MAKEFLAGS uninstall DESTDIR="$SPDK_WORKSPACE" prefix=/usr
-	if [[ $(find "$SPDK_WORKSPACE/usr" -maxdepth 1 -mindepth 1 | wc -l) -ne 2 ]] || [[ $(find "$SPDK_WORKSPACE/usr/lib/" -maxdepth 1 -mindepth 1 | wc -l) -ne 1 ]]; then
-		ls -lR "$SPDK_WORKSPACE"
-		echo "Make uninstall failed"
-		exit 1
-	fi
-}
-
-function build_doc() {
-	local doxygenv
-	doxygenv=$(doxygen --version)
-
-	$MAKE -C "$rootdir"/doc --no-print-directory $MAKEFLAGS &> "$out"/doxygen.log
-	if [ -s "$out"/doxygen.log ]; then
-		cat "$out"/doxygen.log
-		echo "Doxygen errors found!"
-		eq "$doxygenv" 1.8.20 || exit 1
-		echo "Doxygen $doxygenv detected, all warnings are potentially false positives, continuing the test"
-	fi
-	if hash pdflatex 2> /dev/null; then
-		$MAKE -C "$rootdir"/doc/output/latex --no-print-directory $MAKEFLAGS &>> "$out"/doxygen.log
-	fi
-	mkdir -p "$out"/doc
-	mv "$rootdir"/doc/output/html "$out"/doc
-	if [ -f "$rootdir"/doc/output/latex/refman.pdf ]; then
-		mv "$rootdir"/doc/output/latex/refman.pdf "$out"/doc/spdk.pdf
-	fi
-	$MAKE -C "$rootdir"/doc --no-print-directory $MAKEFLAGS clean &>> "$out"/doxygen.log
-	if [ -s "$out"/doxygen.log ]; then
-		# Save the log as an artifact in case we are working with potentially broken version
-		eq "$doxygenv" 1.8.20 || rm "$out"/doxygen.log
-	fi
-	rm -rf "$rootdir"/doc/output
-}
-
-function autobuild_test_suite() {
-	run_test "autobuild_check_format" ./scripts/check_format.sh
-	run_test "autobuild_external_code" sudo -E --preserve-env=PATH LD_LIBRARY_PATH=$LD_LIBRARY_PATH $rootdir/test/external_code/test_make.sh $rootdir
-	run_test "autobuild_check_so_deps" $rootdir/test/make/check_so_deps.sh $1
-	./configure $config_params --without-shared
-	$MAKE $MAKEFLAGS
-	run_test "autobuild_generated_files_check" porcelain_check
-	run_test "autobuild_header_dependency_check" header_dependency_check
-	run_test "autobuild_make_install" $MAKE $MAKEFLAGS install DESTDIR="$SPDK_WORKSPACE" prefix=/usr
-	run_test "autobuild_make_uninstall" test_make_uninstall
-	run_test "autobuild_build_doc" build_doc
-}
-
-function unittest_build() {
-	"$rootdir/configure" $config_params --without-shared
-	$MAKE $MAKEFLAGS
-}
-
-if [ $SPDK_RUN_VALGRIND -eq 1 ]; then
-	run_test "valgrind" echo "using valgrind"
-fi
-
 if [ $SPDK_RUN_ASAN -eq 1 ]; then
 	run_test "asan" echo "using asan"
 fi
@@ -323,28 +25,46 @@ if [ $SPDK_RUN_UBSAN -eq 1 ]; then
 fi
 
 if [ -n "$SPDK_TEST_NATIVE_DPDK" ]; then
-	run_test "build_native_dpdk" build_native_dpdk
+	build_native_dpdk
 fi
 
-./configure $config_params
+case "$SPDK_TEST_AUTOBUILD" in
-echo "** START ** Info for Hostname: $HOSTNAME"
+	full)
-uname -a
+		$rootdir/configure $config_params
-$MAKE cc_version
+		echo "** START ** Info for Hostname: $HOSTNAME"
-$MAKE cxx_version
+		uname -a
-echo "** END ** Info for Hostname: $HOSTNAME"
+		$MAKE cc_version
+		$MAKE cxx_version
+		echo "** END ** Info for Hostname: $HOSTNAME"
+		;;
+	ext | tiny | "") ;;
+	*)
+		echo "ERROR: supported values for SPDK_TEST_AUTOBUILD are 'full', 'tiny' and 'ext'"
+		exit 1
+		;;
+esac
 
 if [[ $SPDK_TEST_OCF -eq 1 ]]; then
-	run_test "autobuild_ocf_precompile" ocf_precompile
+	ocf_precompile
 fi
 
-if [[ $SPDK_TEST_AUTOBUILD -eq 1 ]]; then
+if [[ $SPDK_TEST_FUZZER -eq 1 ]]; then
-	run_test "autobuild" autobuild_test_suite $1
+	llvm_precompile
+fi
+
+if [[ -n $SPDK_TEST_AUTOBUILD ]]; then
+	autobuild_test_suite
 elif [[ $SPDK_TEST_UNITTEST -eq 1 ]]; then
-	run_test "unittest_build" unittest_build
+	unittest_build
 elif [[ $SPDK_TEST_SCANBUILD -eq 1 ]]; then
-	run_test "scanbuild_make" scanbuild_make
+	scanbuild_make
 else
-	# if we aren't testing the unittests, build with shared objects.
+	if [[ $SPDK_TEST_FUZZER -eq 1 ]]; then
-	./configure $config_params --with-shared
+		# if we are testing nvmf fuzz with llvm lib, --with-shared will cause lib link fail
+		$rootdir/configure $config_params
+	else
+		# if we aren't testing the unittests, build with shared objects.
+		$rootdir/configure $config_params --with-shared
+	fi
 	run_test "make" $MAKE $MAKEFLAGS
 fi

autopackage.sh

@@ -1,96 +1,19 @@
 #!/usr/bin/env bash
-
+#  SPDX-License-Identifier: BSD-3-Clause
-set -e
+#  Copyright (C) 2015 Intel Corporation
-
+#  All rights reserved.
-# If the configuration of tests is not provided, no tests will be carried out.
+#
-if [[ ! -f $1 ]]; then
-	echo "ERROR: SPDK test configuration not specified"
-	exit 1
-fi
-
-source "$1"
 
 rootdir=$(readlink -f $(dirname $0))
-testdir=$rootdir # to get the storage space for tests
+source "$rootdir/test/common/autobuild_common.sh"
-source "$rootdir/test/common/autotest_common.sh"
-
-function build_rpms() (
-	local version rpms
-
-	# Make sure linker will not attempt to look under DPDK's repo dir to get the libs
-	unset -v LD_LIBRARY_PATH
-
-	install_uninstall_rpms() {
-		rpms=("${1:-$builddir/rpm/}/x86_64/"*.rpm)
-
-		sudo rpm -i "${rpms[@]}"
-		# Check if we can find one of the apps in the PATH now and verify if it doesn't miss
-		# any libs.
-		LIST_LIBS=yes "$rootdir/rpmbuild/rpm-deps.sh" "${SPDK_APP[@]##*/}"
-		rm "${rpms[@]}"
-		rpms=("${rpms[@]##*/}") rpms=("${rpms[@]%.rpm}")
-		sudo rpm -e "${rpms[@]}"
-	}
-
-	build_rpm() {
-		# Separate run to see the final .spec in use
-		GEN_SPEC=yes BUILDDIR=$builddir MAKEFLAGS="$MAKEFLAGS" SPDK_VERSION="$version" DEPS=no "$rootdir/rpmbuild/rpm.sh" "$@"
-		# Actual build
-		BUILDDIR=$builddir MAKEFLAGS="$MAKEFLAGS" SPDK_VERSION="$version" DEPS=no "$rootdir/rpmbuild/rpm.sh" "$@"
-		install_uninstall_rpms
-	}
-
-	build_rpm_with_rpmed_dpdk() {
-		sudo dnf install -y dpdk-devel
-		build_rpm --with-shared --with-dpdk
-	}
-
-	build_rpm_from_gen_spec() {
-		GEN_SPEC=yes \
-			USE_DEFAULT_DIRS=yes \
-			MAKEFLAGS="$MAKEFLAGS" \
-			SPDK_VERSION="$version" \
-			DEPS=no \
-			"$rootdir/rpmbuild/rpm.sh" --with-shared > "$builddir/gen-spdk.spec"
-
-		# Default locations should be in use.
-		sourcedir=$(rpm --eval "%{_sourcedir}") rpmdir=$(rpm --eval "%{_rpmdir}")
-		mkdir -p "$sourcedir" "$rpmdir"
-
-		# Prepare the source at the default location - default %prep step requires
-		# extra dir inside the source package hence the dance with symlinking to
-		# the repo (after the extraction source should be under spdk-$version/) -
-		# make sure symlinking is done outside of the repo to avoid nasty loops.
-		ln -s "$rootdir" "/tmp/spdk-$version"
-		tar -czhf "$sourcedir/spdk-$version.tar.gz" -C /tmp "spdk-$version"
-
-		# See rpm.sh for details on the PYTHONPATH HACK
-		PYTHONPATH="$(python3 -c "import sys; print('%s' % ':'.join(sys.path)[1:])")" \
-			rpmbuild -ba "$builddir/gen-spdk.spec"
-		install_uninstall_rpms "$rpmdir"
-	}
-
-	version="test_shared"
-	builddir=$SPDK_TEST_STORAGE/test-rpm
-
-	run_test "build_shared_rpm" build_rpm --with-shared
-	if [[ $RUN_NIGHTLY -eq 1 ]]; then
-		run_test "build_shared_rpm_with_rpmed_dpdk" build_rpm_with_rpmed_dpdk
-		run_test "build_rpm_from_gen_spec" build_rpm_from_gen_spec
-		if [[ -n $SPDK_TEST_NATIVE_DPDK ]]; then
-			version="test_shared_native_dpdk"
-			run_test "build_shared_native_dpdk_rpm" build_rpm --with-shared --with-dpdk="$SPDK_RUN_EXTERNAL_DPDK"
-		fi
-	fi
-)
-
-out=$PWD
 
 MAKEFLAGS=${MAKEFLAGS:--j16}
 cd $rootdir
 
 timing_enter porcelain_check
-$MAKE clean
+if [[ -e $rootdir/mk/config.mk ]]; then
+	$MAKE clean
+fi
 
 if [ $(git status --porcelain --ignore-submodules | wc -l) -ne 0 ]; then
 	echo make clean left the following files:
@@ -100,11 +23,11 @@ fi
 timing_exit porcelain_check
 
 if [[ $SPDK_TEST_RELEASE_BUILD -eq 1 ]]; then
-	run_test "build_rpms" build_rpms
+	build_packaging
 	$MAKE clean
 fi
 
-if [[ $RUN_NIGHTLY -eq 0 ]]; then
+if [[ $RUN_NIGHTLY -eq 0 || $SPDK_TEST_UNITTEST -eq 0 ]]; then
 	timing_finish
 	exit 0
 fi
@@ -118,10 +41,10 @@ if [ $(uname -s) = Linux ]; then
 		LD=$(type -P ld.gold)
 		export LD
 	fi
-	./configure $config_params --enable-lto
+	$rootdir/configure $config_params --enable-lto
 else
 	# LTO needs a special compiler to work on BSD.
-	./configure $config_params
+	$rootdir/configure $config_params
 fi
 $MAKE ${MAKEFLAGS}
 $MAKE ${MAKEFLAGS} clean

autorun.sh

@@ -1,4 +1,8 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2016 Intel Corporation
+#  All rights reserved.
+#
 
 set -e
 
@@ -22,4 +26,7 @@ $rootdir/autobuild.sh "$conf"
 if ((SPDK_TEST_UNITTEST == 1 || SPDK_RUN_FUNCTIONAL_TEST == 1)); then
 	sudo -E $rootdir/autotest.sh "$conf"
 fi
-$rootdir/autopackage.sh "$conf"
+
+if [[ $SPDK_TEST_AUTOBUILD != 'tiny' ]]; then
+	$rootdir/autopackage.sh "$conf"
+fi

autorun_post.py

@@ -1,21 +1,41 @@
 #!/usr/bin/python3
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2017 Intel Corporation.
+#  All rights reserved.
+
 
 import shutil
 import subprocess
 import argparse
+import itertools
 import os
+import sys
 import glob
 import re
 import pandas as pd
 
 
-def highest_value(inp):
+def generateTestCompletionTableByTest(output_dir, data_table):
-    ret_value = False
+    columns_to_group = ['Domain', 'Test', 'Agent']
-    for x in inp:
+
-        if x:
+    total_tests_number = len(data_table.groupby('Test'))
-            return True
+
-    else:
+    has_agent = data_table['Agent'] != 'None'
-        return False
+    data_table_with_agent = data_table[has_agent]
+    executed_tests = len(data_table_with_agent.groupby('Test'))
+    tests_executions = len(data_table_with_agent.groupby(columns_to_group))
+
+    pivot_by_test = pd.pivot_table(data_table, index=columns_to_group)
+
+    output_file = os.path.join(output_dir, 'post_process', 'completions_table_by_test.html')
+    with open(output_file, 'w') as f:
+        table_row = '<tr><td>{}</td><td>{}</td>\n'
+        f.write('<table>\n')
+        f.write(table_row.format('Total number of tests', total_tests_number))
+        f.write(table_row.format('Tests executed', executed_tests))
+        f.write(table_row.format('Number of test executions', tests_executions))
+        f.write('</table>\n')
+        f.write(pivot_by_test.to_html(None))
 
 
 def generateTestCompletionTables(output_dir, completion_table):
@@ -25,11 +45,12 @@ def generateTestCompletionTables(output_dir, completion_table):
 
     pivot_by_agent = pd.pivot_table(data_table, index=["Agent", "Domain", "Test"])
     pivot_by_agent.to_html(os.path.join(output_dir, "post_process", 'completions_table_by_agent.html'))
-    pivot_by_test = pd.pivot_table(data_table, index=["Domain", "Test", "Agent"])
+
-    pivot_by_test.to_html(os.path.join(output_dir, "post_process", 'completions_table_by_test.html'))
+    generateTestCompletionTableByTest(output_dir, data_table)
-    pivot_by_asan = pd.pivot_table(data_table, index=["Domain", "Test"], values=["With Asan"], aggfunc=highest_value)
+
+    pivot_by_asan = pd.pivot_table(data_table, index=["Domain", "Test"], values=["With Asan"], aggfunc=any)
     pivot_by_asan.to_html(os.path.join(output_dir, "post_process", 'completions_table_by_asan.html'))
-    pivot_by_ubsan = pd.pivot_table(data_table, index=["Domain", "Test"], values=["With UBsan"], aggfunc=highest_value)
+    pivot_by_ubsan = pd.pivot_table(data_table, index=["Domain", "Test"], values=["With UBsan"], aggfunc=any)
     pivot_by_ubsan.to_html(os.path.join(output_dir, "post_process", 'completions_table_by_ubsan.html'))
 
 
@@ -41,34 +62,39 @@ def generateCoverageReport(output_dir, repo_dir):
     if len(covfiles) == 0:
         return
     lcov_opts = [
-        '--rc lcov_branch_coverage=1',
+        '--rc', 'lcov_branch_coverage=1',
-        '--rc lcov_function_coverage=1',
+        '--rc', 'lcov_function_coverage=1',
-        '--rc genhtml_branch_coverage=1',
+        '--rc', 'genhtml_branch_coverage=1',
-        '--rc genhtml_function_coverage=1',
+        '--rc', 'genhtml_function_coverage=1',
-        '--rc genhtml_legend=1',
+        '--rc', 'genhtml_legend=1',
-        '--rc geninfo_all_blocks=1',
+        '--rc', 'geninfo_all_blocks=1',
     ]
+
+    # HACK: This is a workaround for some odd CI assumptions
+    details = '--show-details'
+
     cov_total = os.path.abspath(os.path.join(output_dir, 'cov_total.info'))
     coverage = os.path.join(output_dir, 'coverage')
-    lcov = 'lcov' + ' ' + ' '.join(lcov_opts) + ' -q -a ' + ' -a '.join(covfiles) + ' -o ' + cov_total
+    lcov = ['lcov', *lcov_opts, '-q', *itertools.chain(*[('-a', f) for f in covfiles]), '-o', cov_total]
-    genhtml = 'genhtml' + ' ' + ' '.join(lcov_opts) + ' -q ' + cov_total + ' --legend' + ' -t "Combined" --show-details -o ' + coverage
+    genhtml = ['genhtml', *lcov_opts, '-q', cov_total, '--legend', '-t', 'Combined', *details.split(), '-o', coverage]
     try:
-        subprocess.check_call([lcov], shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        subprocess.check_call(lcov)
     except subprocess.CalledProcessError as e:
         print("lcov failed")
         print(e)
         return
-    cov_total_file = open(cov_total, 'r')
+
+    with open(cov_total, 'r') as cov_total_file:
+        file_contents = cov_total_file.readlines()
+
     replacement = "SF:" + repo_dir
-    file_contents = cov_total_file.readlines()
-    cov_total_file.close()
     os.remove(cov_total)
     with open(cov_total, 'w+') as file:
         for Line in file_contents:
             Line = re.sub("^SF:.*/repo", replacement, Line)
             file.write(Line + '\n')
     try:
-        subprocess.check_call([genhtml], shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        subprocess.check_call(genhtml)
     except subprocess.CalledProcessError as e:
         print("genhtml failed")
         print(e)
@@ -129,9 +155,9 @@ def getSkippedTests(repo_dir):
     skipped_test_file = os.path.join(repo_dir, "test", "common", "skipped_tests.txt")
     if not os.path.exists(skipped_test_file):
         return []
-    else:
+
-        with open(skipped_test_file, "r") as skipped_test_data:
+    with open(skipped_test_file, "r") as skipped_test_data:
-            return [x.strip() for x in skipped_test_data.readlines() if "#" not in x and x.strip() != '']
+        return [x.strip() for x in skipped_test_data.readlines() if "#" not in x and x.strip() != '']
 
 
 def confirmPerPatchTests(test_list, skiplist):
@@ -140,7 +166,7 @@ def confirmPerPatchTests(test_list, skiplist):
     if len(missing_tests) > 0:
         print("Not all tests were run. Failing the build.")
         print(missing_tests)
-        exit(1)
+        sys.exit(1)
 
 
 def aggregateCompletedTests(output_dir, repo_dir, skip_confirm=False):
@@ -174,6 +200,8 @@ def aggregateCompletedTests(output_dir, repo_dir, skip_confirm=False):
     if not skip_confirm:
         confirmPerPatchTests(test_list, skipped_tests)
 
+    return 0
+
 
 def main(output_dir, repo_dir, skip_confirm=False):
     print("-----Begin Post Process Script------")

autotest.sh

@@ -1,4 +1,8 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2015 Intel Corporation
+#  All rights reserved.
+#
 
 rootdir=$(readlink -f $(dirname $0))
 
@@ -9,9 +13,6 @@ if [[ ! -f $1 ]]; then
 	exit 1
 fi
 
-# always test with SPDK shared objects.
-export SPDK_LIB_DIR="$rootdir/build/lib"
-
 # Autotest.sh, as part of autorun.sh, runs in a different
 # shell process than autobuild.sh. Use helper file to pass
 # over env variable containing libraries paths.
@@ -31,8 +32,12 @@ fi
 if [ $(uname -s) = Linux ]; then
 	old_core_pattern=$(< /proc/sys/kernel/core_pattern)
 	mkdir -p "$output_dir/coredumps"
-	# set core_pattern to a known value to avoid ABRT, systemd-coredump, etc.
+	# Set core_pattern to a known value to avoid ABRT, systemd-coredump, etc.
-	echo "|$rootdir/scripts/core-collector.sh %P %s %t %c $output_dir/coredumps" > /proc/sys/kernel/core_pattern
+	# Dump the $output_dir path to a file so collector can pick it up while executing.
+	# We don't set in in the core_pattern command line because of the string length limitation
+	# of 128 bytes. See 'man core 5' for details.
+	echo "|$rootdir/scripts/core-collector.sh %P %s %t" > /proc/sys/kernel/core_pattern
+	echo "$output_dir/coredumps" > "$rootdir/.coredump_path"
 
 	# make sure nbd (network block device) driver is loaded if it is available
 	# this ensures that when tests need to use nbd, it will be fully initialized
@@ -44,7 +49,7 @@ if [ $(uname -s) = Linux ]; then
 	fi
 fi
 
-trap "autotest_cleanup || :; revert_soft_roce; exit 1" SIGINT SIGTERM EXIT
+trap "autotest_cleanup || :; exit 1" SIGINT SIGTERM EXIT
 
 timing_enter autotest
 
@@ -55,14 +60,13 @@ out=$output_dir
 cd $src
 
 freebsd_update_contigmem_mod
+freebsd_set_maxsock_buf
 
 # lcov takes considerable time to process clang coverage.
 # Disabling lcov allow us to do this.
 # More information: https://github.com/spdk/spdk/issues/1693
 CC_TYPE=$(grep CC_TYPE mk/cc.mk)
 if hash lcov && ! [[ "$CC_TYPE" == *"clang"* ]]; then
-	# setup output dir for unittest.sh
-	export UT_COVERAGE=$out/ut_coverage
 	export LCOV_OPTS="
 		--rc lcov_branch_coverage=1
 		--rc lcov_function_coverage=1
@@ -79,12 +83,12 @@ if hash lcov && ! [[ "$CC_TYPE" == *"clang"* ]]; then
 fi
 
 # Make sure the disks are clean (no leftover partition tables)
-timing_enter cleanup
+timing_enter pre_cleanup
 # Remove old domain socket pathname just in case
 rm -f /var/tmp/spdk*.sock
 
 # Load the kernel driver
-./scripts/setup.sh reset
+$rootdir/scripts/setup.sh reset
 
 get_zoned_devs
 
@@ -110,22 +114,26 @@ done
 
 sync
 
+if ! xtrace_disable_per_cmd reap_spdk_processes; then
+	echo "WARNING: Lingering SPDK processes were detected. Testing environment may be unstable" >&2
+fi
+
 if [ $(uname -s) = Linux ]; then
 	run_test "setup.sh" "$rootdir/test/setup/test-setup.sh"
 fi
 
-./scripts/setup.sh status
+$rootdir/scripts/setup.sh status
 
 if [[ $(uname -s) == Linux ]]; then
 	# Revert NVMe namespaces to default state
 	nvme_namespace_revert
 fi
 
-timing_exit cleanup
+timing_exit pre_cleanup
 
 # set up huge pages
 timing_enter afterboot
-./scripts/setup.sh
+$rootdir/scripts/setup.sh
 timing_exit afterboot
 
 # Revert existing OPAL to factory settings that may have been left from earlier failed tests.
@@ -137,38 +145,39 @@ opal_revert_cleanup
 #####################
 
 if [ $SPDK_TEST_UNITTEST -eq 1 ]; then
-	run_test "unittest" ./test/unit/unittest.sh
+	run_test "unittest" $rootdir/test/unit/unittest.sh
-	run_test "env" test/env/env.sh
 fi
 
 if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then
-	if [[ $SPDK_TEST_CRYPTO -eq 1 || $SPDK_TEST_REDUCE -eq 1 ]]; then
+	if [[ $SPDK_TEST_CRYPTO -eq 1 || $SPDK_TEST_VBDEV_COMPRESS -eq 1 ]]; then
 		if [[ $SPDK_TEST_USE_IGB_UIO -eq 1 ]]; then
-			./scripts/qat_setup.sh igb_uio
+			$rootdir/scripts/qat_setup.sh igb_uio
 		else
-			./scripts/qat_setup.sh
+			$rootdir/scripts/qat_setup.sh
 		fi
 	fi
 	timing_enter lib
 
-	run_test "rpc" test/rpc/rpc.sh
+	run_test "env" $rootdir/test/env/env.sh
-	run_test "rpc_client" test/rpc_client/rpc_client.sh
+	run_test "rpc" $rootdir/test/rpc/rpc.sh
-	run_test "json_config" ./test/json_config/json_config.sh
+	run_test "rpc_client" $rootdir/test/rpc_client/rpc_client.sh
-	run_test "json_config_extra_key" ./test/json_config/json_config_extra_key.sh
+	run_test "json_config" $rootdir/test/json_config/json_config.sh
-	run_test "alias_rpc" test/json_config/alias_rpc/alias_rpc.sh
+	run_test "json_config_extra_key" $rootdir/test/json_config/json_config_extra_key.sh
-	run_test "spdkcli_tcp" test/spdkcli/tcp.sh
+	run_test "alias_rpc" $rootdir/test/json_config/alias_rpc/alias_rpc.sh
-	run_test "dpdk_mem_utility" test/dpdk_memory_utility/test_dpdk_mem_info.sh
+	run_test "spdkcli_tcp" $rootdir/test/spdkcli/tcp.sh
-	run_test "event" test/event/event.sh
+	run_test "dpdk_mem_utility" $rootdir/test/dpdk_memory_utility/test_dpdk_mem_info.sh
-	run_test "thread" test/thread/thread.sh
+	run_test "event" $rootdir/test/event/event.sh
-	run_test "accel_engine" test/accel_engine/accel_engine.sh
+	run_test "thread" $rootdir/test/thread/thread.sh
+	run_test "accel" $rootdir/test/accel/accel.sh
+	run_test "app_cmdline" $rootdir/test/app/cmdline.sh
 
 	if [ $SPDK_TEST_BLOCKDEV -eq 1 ]; then
-		run_test "blockdev_general" test/bdev/blockdev.sh
+		run_test "blockdev_general" $rootdir/test/bdev/blockdev.sh
-		run_test "bdev_raid" test/bdev/bdev_raid.sh
+		run_test "bdev_raid" $rootdir/test/bdev/bdev_raid.sh
-		run_test "bdevperf_config" test/bdev/bdevperf/test_config.sh
+		run_test "bdevperf_config" $rootdir/test/bdev/bdevperf/test_config.sh
 		if [[ $(uname -s) == Linux ]]; then
-			run_test "reactor_set_interrupt" test/interrupt/reactor_set_interrupt.sh
+			run_test "reactor_set_interrupt" $rootdir/test/interrupt/reactor_set_interrupt.sh
-			run_test "reap_unregistered_poller" test/interrupt/reap_unregistered_poller.sh
+			run_test "reap_unregistered_poller" $rootdir/test/interrupt/reap_unregistered_poller.sh
 		fi
 	fi
 
@@ -180,90 +189,98 @@ if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then
 			# job timeout. Avoid that by skipping these tests - this should not affect the coverage
 			# since dd tests are still run as part of the vg jobs.
 			if [[ $SPDK_TEST_CRYPTO -eq 0 ]]; then
-				run_test "spdk_dd" test/dd/dd.sh
+				run_test "spdk_dd" $rootdir/test/dd/dd.sh
 			fi
 		fi
 	fi
 
 	if [ $SPDK_TEST_NVME -eq 1 ]; then
-		run_test "blockdev_nvme" test/bdev/blockdev.sh "nvme"
+		run_test "blockdev_nvme" $rootdir/test/bdev/blockdev.sh "nvme"
 		if [[ $(uname -s) == Linux ]]; then
-			run_test "blockdev_nvme_gpt" test/bdev/blockdev.sh "gpt"
+			run_test "blockdev_nvme_gpt" $rootdir/test/bdev/blockdev.sh "gpt"
 		fi
-		run_test "nvme" test/nvme/nvme.sh
+		run_test "nvme" $rootdir/test/nvme/nvme.sh
 		if [[ $SPDK_TEST_NVME_PMR -eq 1 ]]; then
-			run_test "nvme_pmr" test/nvme/nvme_pmr.sh
+			run_test "nvme_pmr" $rootdir/test/nvme/nvme_pmr.sh
 		fi
 		if [[ $SPDK_TEST_NVME_SCC -eq 1 ]]; then
-			run_test "nvme_scc" test/nvme/nvme_scc.sh
+			run_test "nvme_scc" $rootdir/test/nvme/nvme_scc.sh
 		fi
 		if [[ $SPDK_TEST_NVME_BP -eq 1 ]]; then
-			run_test "nvme_bp" test/nvme/nvme_bp.sh
+			run_test "nvme_bp" $rootdir/test/nvme/nvme_bp.sh
 		fi
 		if [[ $SPDK_TEST_NVME_CUSE -eq 1 ]]; then
-			run_test "nvme_cuse" test/nvme/cuse/nvme_cuse.sh
+			run_test "nvme_cuse" $rootdir/test/nvme/cuse/nvme_cuse.sh
 		fi
 		if [[ $SPDK_TEST_NVME_CMB -eq 1 ]]; then
-			run_test "nvme_cmb" test/nvme/cmb/cmb.sh
+			run_test "nvme_cmb" $rootdir/test/nvme/cmb/cmb.sh
+		fi
+		if [[ $SPDK_TEST_NVME_FDP -eq 1 ]]; then
+			run_test "nvme_fdp" test/nvme/nvme_fdp.sh
 		fi
 
 		if [[ $SPDK_TEST_NVME_ZNS -eq 1 ]]; then
-			run_test "nvme_zns" test/nvme/zns/zns.sh
+			run_test "nvme_zns" $rootdir/test/nvme/zns/zns.sh
 		fi
 
-		run_test "nvme_rpc" test/nvme/nvme_rpc.sh
+		run_test "nvme_rpc" $rootdir/test/nvme/nvme_rpc.sh
+		run_test "nvme_rpc_timeouts" $rootdir/test/nvme/nvme_rpc_timeouts.sh
 		# Only test hotplug without ASAN enabled. Since if it is
 		# enabled, it catches SEGV earlier than our handler which
 		# breaks the hotplug logic.
-		if [ $SPDK_RUN_ASAN -eq 0 ]; then
+		if [ $SPDK_RUN_ASAN -eq 0 ] && [ $(uname -s) = Linux ]; then
-			run_test "nvme_hotplug" test/nvme/hotplug.sh
+			run_test "sw_hotplug" $rootdir/test/nvme/sw_hotplug.sh
+		fi
+
+		if [[ $SPDK_TEST_XNVME -eq 1 ]]; then
+			run_test "nvme_xnvme" $rootdir/test/nvme/xnvme/xnvme.sh
+			run_test "blockdev_xnvme" $rootdir/test/bdev/blockdev.sh "xnvme"
+			# Run ublk with xnvme since they have similar kernel dependencies
+			run_test "ublk" $rootdir/test/ublk/ublk.sh
 		fi
 	fi
 
 	if [ $SPDK_TEST_IOAT -eq 1 ]; then
-		run_test "ioat" test/ioat/ioat.sh
+		run_test "ioat" $rootdir/test/ioat/ioat.sh
 	fi
 
 	timing_exit lib
 
 	if [ $SPDK_TEST_ISCSI -eq 1 ]; then
-		run_test "iscsi_tgt" ./test/iscsi_tgt/iscsi_tgt.sh
+		run_test "iscsi_tgt" $rootdir/test/iscsi_tgt/iscsi_tgt.sh
-		run_test "spdkcli_iscsi" ./test/spdkcli/iscsi.sh
+		run_test "spdkcli_iscsi" $rootdir/test/spdkcli/iscsi.sh
 
 		# Run raid spdkcli test under iSCSI since blockdev tests run on systems that can't run spdkcli yet
-		run_test "spdkcli_raid" test/spdkcli/raid.sh
+		run_test "spdkcli_raid" $rootdir/test/spdkcli/raid.sh
 	fi
 
 	if [ $SPDK_TEST_BLOBFS -eq 1 ]; then
-		run_test "rocksdb" ./test/blobfs/rocksdb/rocksdb.sh
+		run_test "rocksdb" $rootdir/test/blobfs/rocksdb/rocksdb.sh
-		run_test "blobstore" ./test/blobstore/blobstore.sh
+		run_test "blobstore" $rootdir/test/blobstore/blobstore.sh
-		run_test "blobfs" ./test/blobfs/blobfs.sh
+		run_test "blobstore_grow" $rootdir/test/blobstore/blobstore_grow/blobstore_grow.sh
+		run_test "blobfs" $rootdir/test/blobfs/blobfs.sh
 		run_test "hello_blob" $SPDK_EXAMPLE_DIR/hello_blob \
 			examples/blob/hello_world/hello_blob.json
 	fi
 
 	if [ $SPDK_TEST_NVMF -eq 1 ]; then
+		export NET_TYPE
 		# The NVMe-oF run test cases are split out like this so that the parser that compiles the
 		# list of all tests can properly differentiate them. Please do not merge them into one line.
 		if [ "$SPDK_TEST_NVMF_TRANSPORT" = "rdma" ]; then
-			timing_enter rdma_setup
+			run_test "nvmf_rdma" $rootdir/test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-			rdma_device_init
+			run_test "spdkcli_nvmf_rdma" $rootdir/test/spdkcli/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-			timing_exit rdma_setup
-			run_test "nvmf_rdma" ./test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-			run_test "spdkcli_nvmf_rdma" ./test/spdkcli/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
 		elif [ "$SPDK_TEST_NVMF_TRANSPORT" = "tcp" ]; then
-			timing_enter tcp_setup
+			run_test "nvmf_tcp" $rootdir/test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-			tcp_device_init
-			timing_exit tcp_setup
-			run_test "nvmf_tcp" ./test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
 			if [[ $SPDK_TEST_URING -eq 0 ]]; then
-				run_test "spdkcli_nvmf_tcp" ./test/spdkcli/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
+				run_test "spdkcli_nvmf_tcp" $rootdir/test/spdkcli/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-				run_test "nvmf_identify_passthru" test/nvmf/target/identify_passthru.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
+				run_test "nvmf_identify_passthru" $rootdir/test/nvmf/target/identify_passthru.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
 			fi
-			run_test "nvmf_dif" test/nvmf/target/dif.sh
+			run_test "nvmf_dif" $rootdir/test/nvmf/target/dif.sh
+			run_test "nvmf_abort_qd_sizes" $rootdir/test/nvmf/target/abort_qd_sizes.sh
 		elif [ "$SPDK_TEST_NVMF_TRANSPORT" = "fc" ]; then
-			run_test "nvmf_fc" ./test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
+			run_test "nvmf_fc" $rootdir/test/nvmf/nvmf.sh --transport=$SPDK_TEST_NVMF_TRANSPORT
-			run_test "spdkcli_nvmf_fc" ./test/spdkcli/nvmf.sh
+			run_test "spdkcli_nvmf_fc" $rootdir/test/spdkcli/nvmf.sh
 		else
 			echo "unknown NVMe transport, please specify rdma, tcp, or fc."
 			exit 1
@@ -271,82 +288,86 @@ if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then
 	fi
 
 	if [ $SPDK_TEST_VHOST -eq 1 ]; then
-		run_test "vhost" ./test/vhost/vhost.sh
+		run_test "vhost" $rootdir/test/vhost/vhost.sh
 	fi
 
 	if [ $SPDK_TEST_VFIOUSER_QEMU -eq 1 ]; then
-		run_test "vfio_user_qemu" ./test/vfio_user/vfio_user.sh
+		run_test "vfio_user_qemu" $rootdir/test/vfio_user/vfio_user.sh
 	fi
 
 	if [ $SPDK_TEST_LVOL -eq 1 ]; then
-		run_test "lvol" ./test/lvol/lvol.sh
+		run_test "lvol" $rootdir/test/lvol/lvol.sh
-		run_test "blob_io_wait" ./test/blobstore/blob_io_wait/blob_io_wait.sh
+		run_test "blob_io_wait" $rootdir/test/blobstore/blob_io_wait/blob_io_wait.sh
 	fi
 
 	if [ $SPDK_TEST_VHOST_INIT -eq 1 ]; then
 		timing_enter vhost_initiator
-		run_test "vhost_blockdev" ./test/vhost/initiator/blockdev.sh
+		run_test "vhost_blockdev" $rootdir/test/vhost/initiator/blockdev.sh
-		run_test "spdkcli_virtio" ./test/spdkcli/virtio.sh
+		run_test "spdkcli_virtio" $rootdir/test/spdkcli/virtio.sh
-		run_test "vhost_shared" ./test/vhost/shared/shared.sh
+		run_test "vhost_shared" $rootdir/test/vhost/shared/shared.sh
-		run_test "vhost_fuzz" ./test/vhost/fuzz/fuzz.sh
+		run_test "vhost_fuzz" $rootdir/test/vhost/fuzz/fuzz.sh
 		timing_exit vhost_initiator
 	fi
 
-	if [ $SPDK_TEST_PMDK -eq 1 ]; then
-		run_test "blockdev_pmem" ./test/bdev/blockdev.sh "pmem"
-		run_test "pmem" ./test/pmem/pmem.sh -x
-		run_test "spdkcli_pmem" ./test/spdkcli/pmem.sh
-	fi
-
 	if [ $SPDK_TEST_RBD -eq 1 ]; then
-		run_test "blockdev_rbd" ./test/bdev/blockdev.sh "rbd"
+		run_test "blockdev_rbd" $rootdir/test/bdev/blockdev.sh "rbd"
-		run_test "spdkcli_rbd" ./test/spdkcli/rbd.sh
+		run_test "spdkcli_rbd" $rootdir/test/spdkcli/rbd.sh
 	fi
 
 	if [ $SPDK_TEST_OCF -eq 1 ]; then
-		run_test "ocf" ./test/ocf/ocf.sh
+		run_test "ocf" $rootdir/test/ocf/ocf.sh
 	fi
 
 	if [ $SPDK_TEST_FTL -eq 1 ]; then
-		run_test "ftl" ./test/ftl/ftl.sh
+		run_test "ftl" $rootdir/test/ftl/ftl.sh
 	fi
 
 	if [ $SPDK_TEST_VMD -eq 1 ]; then
-		run_test "vmd" ./test/vmd/vmd.sh
+		run_test "vmd" $rootdir/test/vmd/vmd.sh
 	fi
 
-	if [ $SPDK_TEST_REDUCE -eq 1 ]; then
+	if [ $SPDK_TEST_VBDEV_COMPRESS -eq 1 ]; then
-		run_test "compress_qat" ./test/compress/compress.sh "qat"
+		run_test "compress_compdev" $rootdir/test/compress/compress.sh "compdev"
-		run_test "compress_isal" ./test/compress/compress.sh "isal"
+		run_test "compress_isal" $rootdir/test/compress/compress.sh "isal"
 	fi
 
 	if [ $SPDK_TEST_OPAL -eq 1 ]; then
-		run_test "nvme_opal" ./test/nvme/nvme_opal.sh
+		run_test "nvme_opal" $rootdir/test/nvme/nvme_opal.sh
 	fi
 
 	if [ $SPDK_TEST_CRYPTO -eq 1 ]; then
-		run_test "blockdev_crypto_aesni" ./test/bdev/blockdev.sh "crypto_aesni"
+		run_test "blockdev_crypto_aesni" $rootdir/test/bdev/blockdev.sh "crypto_aesni"
-		# Proceed with the test only if QAT devices are in place
+		run_test "blockdev_crypto_sw" $rootdir/test/bdev/blockdev.sh "crypto_sw"
-		if [[ $(lspci -d:37c8) ]]; then
+		run_test "blockdev_crypto_qat" $rootdir/test/bdev/blockdev.sh "crypto_qat"
-			run_test "blockdev_crypto_qat" ./test/bdev/blockdev.sh "crypto_qat"
+		run_test "chaining" $rootdir/test/bdev/chaining.sh
-		fi
 	fi
 
 	if [[ $SPDK_TEST_SCHEDULER -eq 1 ]]; then
-		run_test "scheduler" ./test/scheduler/scheduler.sh
+		run_test "scheduler" $rootdir/test/scheduler/scheduler.sh
+	fi
+
+	if [[ $SPDK_TEST_SMA -eq 1 ]]; then
+		run_test "sma" $rootdir/test/sma/sma.sh
+	fi
+
+	if [[ $SPDK_TEST_FUZZER -eq 1 ]]; then
+		run_test "llvm_fuzz" $rootdir/test/fuzz/llvm.sh
+	fi
+
+	if [[ $SPDK_TEST_RAID5 -eq 1 ]]; then
+		run_test "blockdev_raid5f" $rootdir/test/bdev/blockdev.sh "raid5f"
 	fi
 fi
 
-timing_enter cleanup
+trap - SIGINT SIGTERM EXIT
+
+timing_enter post_cleanup
 autotest_cleanup
-revert_soft_roce
+timing_exit post_cleanup
-timing_exit cleanup
 
 timing_exit autotest
 chmod a+r $output_dir/timing.txt
 
-trap - SIGINT SIGTERM EXIT
-
 [[ -f "$output_dir/udev.log" ]] && rm -f "$output_dir/udev.log"
 
 if hash lcov && ! [[ "$CC_TYPE" == *"clang"* ]]; then
@@ -355,6 +376,10 @@ if hash lcov && ! [[ "$CC_TYPE" == *"clang"* ]]; then
 	$LCOV -q -a $out/cov_base.info -a $out/cov_test.info -o $out/cov_total.info
 	$LCOV -q -r $out/cov_total.info '*/dpdk/*' -o $out/cov_total.info
 	$LCOV -q -r $out/cov_total.info '/usr/*' -o $out/cov_total.info
-	git clean -f "*.gcda"
+	$LCOV -q -r $out/cov_total.info '*/examples/vmd/*' -o $out/cov_total.info
+	$LCOV -q -r $out/cov_total.info '*/app/spdk_lspci/*' -o $out/cov_total.info
+	$LCOV -q -r $out/cov_total.info '*/app/spdk_top/*' -o $out/cov_total.info
+	owner=$(stat -c "%U" .)
+	sudo -u $owner git clean -f "*.gcda"
 	rm -f cov_base.info cov_test.info OLD_STDOUT OLD_STDERR
 fi

configure

@@ -1,4 +1,9 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2017 Intel Corporation
+#  All rights reserved.
+#  Copyright (c) 2022 Dell Inc, or its subsidiaries.
+#
 
 set -e
 
@@ -22,7 +27,11 @@ function usage() {
 	echo ""
 	echo " --cross-prefix=prefix     Prefix for cross compilation (default: none)"
 	echo "                           example: aarch64-linux-gnu"
-	echo ""
+	echo " --libdir=path             Configure installation path for the libraries (default: \$prefix/lib)"
+	echo " --max-lcores=VAL          DPDK configuration. VAL defines maximum number of lcores supported"
+	echo "                           by EAL, or enables autodetection if set to 'detect'. When 'detect'"
+	echo "                           is specified, DPDK will detect number of cores in the system during"
+	echo "                           compilation, and will set maximum number of lcores to this value"
 	echo " --enable-debug            Configure for debug builds"
 	echo " --enable-werror           Treat compiler warnings as errors"
 	echo " --enable-asan             Enable address sanitizer"
@@ -51,22 +60,28 @@ function usage() {
 	echo "                           Implies --without-dpdk."
 	echo " --with-idxd               Build the IDXD library and accel framework plug-in module."
 	echo " --without-idxd            Disabled while experimental. Only built for x86 when enabled."
-	echo " --with-crypto             Build vbdev crypto module."
+	echo " --with-crypto             Build isa-l-crypto and vbdev crypto module. No path required."
-	echo " --without-crypto          No path required."
+	echo " --without-crypto          Disable isa-l-crypto and vbdev crypto module."
 	echo " --with-fio[=DIR]          Build fio_plugin."
 	echo " --without-fio             default: /usr/src/fio"
+	echo " --with-xnvme              Build xNVMe bdev module."
+	echo " --without-xnvme           No path required."
 	echo " --with-vhost              Build vhost target. Enabled by default."
 	echo " --without-vhost           No path required."
 	echo " --with-virtio             Build vhost initiator and virtio-pci bdev modules."
 	echo " --without-virtio          No path required."
-	echo " --with-vfio-user[=DIR]    Build custom vfio-user transport for NVMf target and NVMe initiator."
+	echo " --with-vfio-user[=DIR]    Build custom vfio-user transport for NVMf target and vfio-user target."
-	echo " --without-vfio-user       example: /usr/src/libvfio-user"
+	echo "                           vfio-user initiator is always built-in in Linux."
-	echo " --with-pmdk[=DIR]         Build persistent memory bdev."
+	echo "                           example: /usr/src/libvfio-user"
-	echo " --without-pmdk            example: /usr/share/pmdk"
+	echo " --without-vfio-user       No path required."
-	echo " --with-reduce             Build vbdev compression module."
+	echo " --with-vbdev-compress     Build vbdev compression module and dependencies."
-	echo " --without-reduce          No path required."
+	echo " --without-vbdev-compress  No path required."
+	echo " --with-dpdk-compressdev   Build accel DPDK compression module and dependencies."
+	echo " --without-dpdk-compressdev No path required."
 	echo " --with-rbd                Build Ceph RBD bdev module."
 	echo " --without-rbd             No path required."
+	echo " --with-ublk               Build ublk library."
+	echo " --without-ublk            No path required."
 	echo " --with-rdma[=DIR]         Build RDMA transport for NVMf target and initiator."
 	echo " --without-rdma            Accepts optional RDMA provider name. Can be \"verbs\" or \"mlx5_dv\"."
 	echo "                           If no provider specified, \"verbs\" provider is used by default."
@@ -74,29 +89,32 @@ function usage() {
 	echo " --without-fc              If an argument is provided, it is considered a directory containing"
 	echo "                           libufc.a and fc_lld.h. Otherwise the regular system paths will"
 	echo "                           be searched."
+	echo " --with-daos[=DIR]         Build DAOS bdev module."
+	echo " --without-daos            No path required."
 	echo " --with-shared             Build spdk shared libraries."
 	echo " --without-shared          No path required."
 	echo " --with-iscsi-initiator    Build with iscsi bdev module."
 	echo " --without-iscsi-initiator No path required."
-	echo " --with-vtune=DIR          Required to profile I/O under Intel VTune Amplifier XE."
+	echo " --with-vtune=DIR          Required to profile I/O under Intel VTune Amplifier XE. (Deprecated)"
 	echo " --without-vtune           example: /opt/intel/vtune_amplifier_xe_version"
 	echo " --with-ocf[=DIR]          Build OCF library and bdev module."
 	echo " --without-ocf             If argument is directory, interpret it as root of OCF repo"
 	echo "                           If argument is file, interpret it as compiled OCF lib"
 	echo "                           If no argument is specified, OCF git submodule is used by default"
 	echo "                           example: /usr/src/ocf/"
-	echo " --with-isal               Build with ISA-L. Enabled by default on x86 and aarch64 architectures."
-	echo " --without-isal            No path required."
 	echo " --with-uring[=DIR]        Build I/O uring bdev or socket module."
 	echo " --without-uring           If an argument is provided, it is considered a directory containing"
 	echo "                           liburing.a and io_uring.h. Otherwise the regular system paths will"
 	echo "                           be searched."
+	echo " --without-uring-zns       Build I/O uring module without ZNS (zoned namespaces) support."
+	echo " --with-openssl[=DIR]      Build OPENSSL with custom path. Otherwise the regular system paths will"
+	echo "                           be searched."
 	echo " --with-fuse               Build FUSE components for mounting a blobfs filesystem."
 	echo " --without-fuse            No path required."
 	echo " --with-nvme-cuse          Build NVMe driver with support for CUSE-based character devices."
 	echo " --without-nvme-cuse       No path required."
-	echo " --with-raid5              Build with bdev_raid module RAID5 support."
+	echo " --with-raid5f             Build with bdev_raid module RAID5f support."
-	echo " --without-raid5           No path required."
+	echo " --without-raid5f          No path required."
 	echo " --with-wpdk=DIR           Build using WPDK to provide support for Windows (experimental)."
 	echo " --without-wpdk            The argument must be a directory containing lib and include."
 	echo " --with-usdt               Build with userspace DTrace probes enabled."
@@ -105,6 +123,10 @@ function usage() {
 	echo "                           Path to clang_rt.fuzzer_no_main library required."
 	echo "                           Requires setting CC and CXX to clang."
 	echo "                           (Typically /usr/lib/llvm-VER/lib/clang/VER/lib/linux/libclang_rt.fuzzer_no_main-ARCH.a)"
+	echo " --with-sma                Generate Storage Management Agent's protobuf interface"
+	echo " --without-sma             No path required."
+	echo " --with-avahi              Build with Avahi mDNS discovery client service enabled in bdev-nvme module."
+	echo " --without-avahi           No path required."
 	echo ""
 	echo "Environment variables:"
 	echo ""
@@ -125,6 +147,9 @@ declare -A CONFIG
 source $rootdir/CONFIG.sh
 rm $rootdir/CONFIG.sh
 
+# Try to expand literal ~ that might have been passed as an option via --long-opt=~/dir.
+set -- "${@//\~/~}"
+
 for i in "$@"; do
 	case "$i" in
 		--cross-prefix=*)
@@ -152,15 +177,6 @@ if [[ $arch == *mingw* ]] || [[ $arch == *windows* ]]; then
 	sys_name=Windows
 fi
 
-# Sanitize default configuration. All parameters set by user explicit should fail
-# Force no ISA-L if non-x86 or non-aarch64 architecture
-if [[ "${CONFIG[ISAL]}" = "y" ]]; then
-	if [[ $arch != x86_64* ]] && [[ $arch != aarch64* ]]; then
-		CONFIG[ISAL]=n
-		echo "Notice: ISA-L not supported for ${arch}. Turning off default feature."
-	fi
-fi
-
 if [[ $sys_name != "Linux" ]]; then
 	# Vhost, rte_vhost library and virtio are only supported on Linux.
 	CONFIG[VHOST]="n"
@@ -168,22 +184,6 @@ if [[ $sys_name != "Linux" ]]; then
 	echo "Notice: Vhost, rte_vhost library and virtio are only supported on Linux. Turning off default feature."
 fi
 
-#check nasm only on x86
-if [[ $arch == x86_64* ]]; then
-	ver=$(nasm -v 2> /dev/null | awk '{print $3}' | awk -Fr '{print $1}')
-	if lt "$ver" 2.14; then
-		# ISA-L, compression & crypto require NASM version 2.14 or newer.
-		CONFIG[ISAL]=n
-		CONFIG[CRYPTO]=n
-		CONFIG[IPSEC_MB]=n
-		CONFIG[REDUCE]=n
-		HAVE_NASM=n
-		echo "Notice: ISA-L, compression & crypto require NASM version 2.14 or newer. Turning off default ISA-L and crypto features."
-	else
-		HAVE_NASM=y
-	fi
-fi
-
 function check_dir() {
 	arg="$1"
 	dir="${arg#*=}"
@@ -193,6 +193,91 @@ function check_dir() {
 	fi
 }
 
+# On x86_64 'clang -dumpmachine' produces x86_64-pc-linux-gnu
+# whereas the dpdk might be built with gcc and its libs lie in
+# x86_64-linux-gnu. Let's find the right libdir for dpdk libs.
+function find_dpdk_arch_libdir() {
+	local dpdk_libdir="$1/lib"
+
+	# Use libdir with 'lib' or 'lib64'
+	if [[ ! -d "$dpdk_libdir" ]]; then
+		dpdk_libdir+="64"
+	fi
+
+	# Checking first what we have with $arch, then clang
+	# variant of arch.
+	arches=("$arch" "$(echo $arch | sed 's/-pc//g')")
+	for a in "${arches[@]}"; do
+		local libdir_arch="$dpdk_libdir/$a"
+		if [[ -d "$libdir_arch" ]]; then
+			echo "$libdir_arch"
+			return
+		fi
+	done
+
+	# Fallback to the libdir without arch component
+	echo "$dpdk_libdir"
+}
+
+function check_IPSec_mb() {
+	local mode=$1
+	local dpdk_libdir=$2
+	local dpdk_incdir=$3
+	local have_ipsec_mb=n
+
+	if [[ $mode = "pkg-config" ]]; then
+		local dpdk_libs
+
+		# Request libdpdk pkg-config settings to figure out if the IPSec_MB is used
+		# as a dependency.
+		# Due to some reason pkg-config shows -lIPSec_MB only with --static option
+		dpdk_libs=$(PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --libs --static libdpdk)
+		if echo "$dpdk_libs" | grep "\-lIPSec_MB" > /dev/null 2>&1; then
+			have_ipsec_mb=y
+		fi
+	elif [[ $mode = "build-config" ]]; then
+		# Use dpdk build config header to check if the IPSec_MB was used.
+		if grep -F "define RTE_CRYPTO_IPSEC_MB 1" "$dpdk_incdir/rte_build_config.h" > /dev/null 2>&1; then
+			have_ipsec_mb=y
+		fi
+	else
+		echo "ERROR: Invalid IPSec_MB checking mode $mode."
+		echo "ERROR: Only \"pkg-config\" and \"build-config\" available."
+		exit 1
+	fi
+	if [[ $have_ipsec_mb = "n" ]]; then
+		CONFIG[IPSEC_MB]=n
+		return
+	fi
+
+	# Since we don't know the library path where the IPSec_MB is located
+	# let's find it out with the ldd utility. This can be a standard location
+	# or a custom build.
+	local librte_crypto_ipsec_mb="$dpdk_libdir/librte_crypto_ipsec_mb.so"
+	if [[ -f "$librte_crypto_ipsec_mb" ]]; then
+		local ipsec_mb_libdir
+
+		ipsec_mb_libdir=$(ldd "$librte_crypto_ipsec_mb" | grep "libIPSec_MB.so" \
+			| sed -e 's/\s*libIPSec_MB.so.*=>\s//' -e 's/\/libIPSec_MB.so.*$//')
+		if [[ -d $ipsec_mb_libdir ]]; then
+			CONFIG[IPSEC_MB]=y
+			CONFIG[IPSEC_MB_DIR]="$ipsec_mb_libdir"
+		elif [[ $ipsec_mb_libdir = "not found" ]]; then
+			# ldconfig cache is broken, old build with refs to non-existing libs, etc.
+			echo "ERROR: Invalid IPSec_MB installation. Library is not found and/or ldconfig cache is broken!"
+			exit 1
+		else
+			# Failed to check for IPSec_MB lib path. Let's just assume it is lives
+			# in one of the standard locations (/usr/lib, etc.).
+			CONFIG[IPSEC_MB]=y
+		fi
+	else
+		# pkg-config says there is IPSec_mb and dpdk lib does not have it. Let's just
+		# assume it is installed in the system in one of the standard locations.
+		CONFIG[IPSEC_MB]=y
+	fi
+}
+
 for i in "$@"; do
 	case "$i" in
 		-h | --help)
@@ -210,6 +295,9 @@ for i in "$@"; do
 		--target-arch=*)
 			CONFIG[ARCH]="${i#*=}"
 			;;
+		--libdir=*)
+			CONFIG[LIBDIR]="${i#*=}"
+			;;
 		--enable-debug)
 			CONFIG[DEBUG]=y
 			;;
@@ -289,11 +377,17 @@ for i in "$@"; do
 			CONFIG[CET]=n
 			;;
 		--with-dpdk)
-			if pkg-config --exists libdpdk; then
+			# Can we use pkg-config?
-				CONFIG[DPDK_LIB_DIR]=$(pkg-config --variable=libdir libdpdk)
+			if command -v "pkg-config" > /dev/null 2>&1 && pkg-config --exists libdpdk; then
-				CONFIG[DPDK_INC_DIR]=$(pkg-config --variable=includedir libdpdk)
+				dpdk_libdir=$(pkg-config --variable=libdir libdpdk)
+				dpdk_libdir=$(readlink -f $dpdk_libdir)
+				dpdk_incdir=$(pkg-config --variable=includedir libdpdk)
+				echo "Using DPDK lib dir $dpdk_libdir"
+				CONFIG[DPDK_LIB_DIR]=$dpdk_libdir
+				CONFIG[DPDK_INC_DIR]=$dpdk_incdir
 				CONFIG[DPDK_PKG_CONFIG]=y
 				CFLAGS="${CFLAGS:+$CFLAGS }$(pkg-config --cflags libdpdk)"
+				check_IPSec_mb "pkg-config" "$dpdk_libdir" "$dpdk_incdir"
 			else
 				echo "libdpdk.pc not found, aborting"
 				exit 1
@@ -301,7 +395,35 @@ for i in "$@"; do
 			;;
 		--with-dpdk=*)
 			check_dir "$i"
-			CONFIG[DPDK_DIR]=$(readlink -f ${i#*=})
+			dpdk_dir=$(readlink -f ${i#*=})
+			dpdk_libdir=$(find_dpdk_arch_libdir $dpdk_dir)
+			dpdk_incdir="$dpdk_dir/include"
+
+			# Can we use pkg-config?
+			if command -v "pkg-config" > /dev/null 2>&1 && PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --exists libdpdk; then
+				echo "Using $dpdk_libdir/pkgconfig for additional libs..."
+				sysroot_dir=$(PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --variable=pc_sysrootdir libdpdk)
+				dpdk_libdir=$(PKG_CONFIG_SYSROOT_DIR='' PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --variable=libdir libdpdk)
+				dpdk_libdir=$(readlink -f "${sysroot_dir}$dpdk_libdir")
+				if ! echo $dpdk_libdir | grep $dpdk_dir > /dev/null 2>&1; then
+					echo "ERROR: pkg-config reported DPDK libdir $dpdk_libdir is out of the directory specified with --with-dpdk="
+					echo "ERROR: do you have another DPDK installed in the system?"
+					exit 1
+				fi
+				CFLAGS="${CFLAGS:+$CFLAGS }$(PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --cflags libdpdk)"
+				dpdk_incdir="${sysroot_dir}$(PKG_CONFIG_PATH="$PKG_CONFIG_PATH:$dpdk_libdir/pkgconfig" pkg-config --variable=includedir libdpdk)"
+				check_IPSec_mb "pkg-config" "$dpdk_libdir" "$dpdk_incdir"
+			else
+				echo "Using $dpdk_incdir/rte_build_config.h for additional libs..."
+
+				check_IPSec_mb "build-config" "$dpdk_libdir" "$dpdk_incdir"
+			fi
+			echo "DPDK libraries: $dpdk_libdir"
+			echo "DPDK includes: $dpdk_incdir"
+			CONFIG[DPDK_DIR]=$dpdk_dir
+			CONFIG[DPDK_LIB_DIR]="$dpdk_libdir"
+			CONFIG[DPDK_INC_DIR]="$dpdk_incdir"
+			CONFIG[DPDK_PKG_CONFIG]=n
 			;;
 		--without-dpdk)
 			CONFIG[DPDK_DIR]=
@@ -316,6 +438,12 @@ for i in "$@"; do
 		--with-env=*)
 			CONFIG[ENV]="${i#*=}"
 			;;
+		--with-ublk)
+			CONFIG[UBLK]=y
+			;;
+		--without-ublk)
+			CONFIG[UBLK]=n
+			;;
 		--with-rbd)
 			CONFIG[RBD]=y
 			;;
@@ -345,6 +473,18 @@ for i in "$@"; do
 			CONFIG[FC]=n
 			CONFIG[FC_PATH]=
 			;;
+		--with-daos)
+			CONFIG[DAOS]=y
+			CONFIG[DAOS_DIR]=""
+			;;
+		--with-daos=*)
+			CONFIG[DAOS]=y
+			check_dir "$i"
+			CONFIG[DAOS_DIR]=$(readlink -f ${i#*=})
+			;;
+		--without-daos)
+			CONFIG[DAOS]=n
+			;;
 		--with-shared)
 			CONFIG[SHARED]=y
 			;;
@@ -387,30 +527,31 @@ for i in "$@"; do
 		--without-vfio-user)
 			CONFIG[VFIO_USER]=n
 			;;
-		--with-pmdk)
+		--with-vbdev-compress)
-			CONFIG[PMDK]=y
+			CONFIG[VBDEV_COMPRESS]=y
-			CONFIG[PMDK_DIR]=""
 			;;
-		--with-pmdk=*)
+		--without-vbdev-compress)
-			CONFIG[PMDK]=y
+			CONFIG[VBDEV_COMPRESS]=n
-			check_dir "$i"
-			CONFIG[PMDK_DIR]=$(readlink -f ${i#*=})
 			;;
-		--without-pmdk)
+		--with-dpdk-compressdev)
-			CONFIG[PMDK]=n
+			CONFIG[DPDK_COMPRESSDEV]=y
 			;;
-		--with-reduce)
+		--without-dpdk-compressdev)
-			CONFIG[REDUCE]=y
+			CONFIG[DPDK_COMPRESSDEV]=n
 			;;
-		--without-reduce)
+		--with-xnvme)
-			CONFIG[REDUCE]=n
+			CONFIG[XNVME]=y
+			;;
+		--without-xnvme)
+			CONFIG[XNVME]=n
 			;;
 		--with-fio) ;&
 		--with-fio=*)
 			if [[ ${i#*=} != "$i" ]]; then
-				CONFIG[FIO_SOURCE_DIR]=$(readlink -f "${i#*=}")
+				CONFIG[FIO_SOURCE_DIR]=${i#*=}
 			fi
 			check_dir "--with-fio=${CONFIG[FIO_SOURCE_DIR]}"
+			CONFIG[FIO_SOURCE_DIR]=$(readlink -f "${CONFIG[FIO_SOURCE_DIR]}")
 			CONFIG[FIO_PLUGIN]=y
 			;;
 		--without-fio)
@@ -427,7 +568,7 @@ for i in "$@"; do
 			;;
 		--with-ocf)
 			CONFIG[OCF]=y
-			CONFIG[OCF_PATH]=$(readlink -f "./ocf")
+			CONFIG[OCF_PATH]=$(readlink -f "$rootdir/ocf")
 			;;
 		--with-ocf=*)
 			CONFIG[OCF]=y
@@ -437,24 +578,26 @@ for i in "$@"; do
 			CONFIG[OCF]=n
 			CONFIG[OCF_PATH]=
 			;;
-		--with-isal)
-			CONFIG[ISAL]=y
-			;;
-		--without-isal)
-			CONFIG[ISAL]=n
-			;;
 		--with-uring=*)
 			CONFIG[URING]=y
 			CONFIG[URING_PATH]=$(readlink -f ${i#*=})
 			;;
 		--with-uring)
 			CONFIG[URING]=y
+			CONFIG[URING_ZNS]=y
 			CONFIG[URING_PATH]=
 			;;
 		--without-uring)
 			CONFIG[URING]=n
 			CONFIG[URING_PATH]=
 			;;
+		--without-uring-zns)
+			CONFIG[URING_ZNS]=n
+			;;
+		--with-openssl=*)
+			check_dir "$i"
+			CONFIG[OPENSSL_PATH]=$(readlink -f ${i#*=})
+			;;
 		--with-fuse)
 			CONFIG[FUSE]=y
 			;;
@@ -467,11 +610,11 @@ for i in "$@"; do
 		--without-nvme-cuse)
 			CONFIG[NVME_CUSE]=n
 			;;
-		--with-raid5)
+		--with-raid5f)
-			CONFIG[RAID5]=y
+			CONFIG[RAID5F]=y
 			;;
-		--without-raid5)
+		--without-raid5f)
-			CONFIG[RAID5]=n
+			CONFIG[RAID5F]=n
 			;;
 		--with-idxd)
 			CONFIG[IDXD]=y
@@ -499,6 +642,27 @@ for i in "$@"; do
 			CONFIG[FUZZER]=n
 			CONFIG[FUZZER_LIB]=
 			;;
+		--with-sma)
+			CONFIG[SMA]=y
+			;;
+		--without-sma)
+			CONFIG[SMA]=n
+			;;
+		--with-avahi)
+			CONFIG[AVAHI]=y
+			;;
+		--without-avahi)
+			CONFIG[AVAHI]=n
+			;;
+		--max-lcores='')
+			echo "Must specify max number of lcores for --max-lcores"
+			usage
+			exit 1
+			;;
+		--max-lcores=*)
+			CONFIG[MAX_LCORES]="${i#*=}"
+			CONFIG["MAX_LCORES"]=${CONFIG["MAX_LCORES"],,}
+			;;
 		--)
 			break
 			;;
@@ -511,25 +675,21 @@ for i in "$@"; do
 done
 
 if [[ $arch == x86_64* ]]; then
-	BUILD_CMD=("$CC" -o /dev/null -x c $CPPFLAGS $CFLAGS $LDFLAGS "-march=native")
+	BUILD_CMD=($CC -o /dev/null -x c $CPPFLAGS $CFLAGS $LDFLAGS "-march=native")
 else
-	BUILD_CMD=("$CC" -o /dev/null -x c $CPPFLAGS $CFLAGS $LDFLAGS)
+	BUILD_CMD=($CC -o /dev/null -x c $CPPFLAGS $CFLAGS $LDFLAGS)
 fi
 BUILD_CMD+=(-I/usr/local/include -L/usr/local/lib)
 
 if [[ "${CONFIG[VFIO_USER]}" = "y" ]]; then
-
+	if ! echo -e '#include <json-c/json.h>' \
-	if ! bash -c "command -v cmake3 cmake" > /dev/null; then
+		| "${BUILD_CMD[@]}" -E - 2> /dev/null; then
-		echo "ERROR: --with-vfio-user requires cmake"
-		echo "Please install then re-run this script"
-		exit 1
-	fi
-	if [[ ! -d /usr/include/json-c ]] && [[ ! -d /usr/local/include/json-c ]]; then
 		echo "ERROR: --with-vfio-user requires json-c-devel"
 		echo "Please install then re-run this script"
 		exit 1
 	fi
-	if [[ ! -e /usr/include/cmocka.h ]] && [[ ! -e /usr/local/include/cmocka.h ]]; then
+	if ! echo -e '#include <cmocka.h>' \
+		| "${BUILD_CMD[@]}" -E - 2> /dev/null; then
 		echo "ERROR: --with-vfio-user requires libcmocka-devel"
 		echo "Please install then re-run this script"
 		exit 1
@@ -555,19 +715,6 @@ if [[ "${CONFIG[IDXD]}" = "y" ]]; then
 
 fi
 
-# Detect architecture and force no ISA-L if non-x86 or non-aarch64 architecture
-if [[ "${CONFIG[ISAL]}" = "y" ]]; then
-	if [[ $arch != x86_64* ]] && [[ $arch != aarch64* ]]; then
-		echo "ERROR: ISA-L cannot be used due to CPU incompatibility."
-		exit 1
-	fi
-fi
-
-if [[ "${CONFIG[ISAL]}" = "n" ]] && [[ "${CONFIG[REDUCE]}" = "y" ]]; then
-	echo "ERROR Conflicting options: --with-reduce is not compatible with --without-isal."
-	exit 1
-fi
-
 if [ -z "${CONFIG[ENV]}" ]; then
 	CONFIG[ENV]=$rootdir/lib/env_dpdk
 	echo "Using default SPDK env in ${CONFIG[ENV]}"
@@ -579,6 +726,11 @@ if [ -z "${CONFIG[ENV]}" ]; then
 			exit 1
 		else
 			CONFIG[DPDK_DIR]="${rootdir}/dpdk/build"
+			# Default ipsec libs
+			if [[ "${CONFIG[CRYPTO]}" = "y" ]] && [[ $arch = x86_64* ]]; then
+				CONFIG[IPSEC_MB]=y
+				CONFIG[IPSEC_MB_DIR]="${rootdir}/intel-ipsec-mb/lib"
+			fi
 			echo "Using default DPDK in ${CONFIG[DPDK_DIR]}"
 		fi
 	fi
@@ -626,6 +778,7 @@ else
 fi
 
 if [ "${CONFIG[VTUNE]}" = "y" ]; then
+	echo "WARNING: VTune support is deprecated."
 	if [ -z "${CONFIG[VTUNE_DIR]}" ]; then
 		echo "When VTune is enabled, you must specify the VTune directory using --with-vtune=path"
 		exit 1
@@ -637,6 +790,11 @@ if [[ "${CONFIG[ASAN]}" = "y" && "${CONFIG[TSAN]}" = "y" ]]; then
 	exit 1
 fi
 
+if [[ "${CONFIG[FIO_PLUGIN]}" = "y" && "${CONFIG[EXAMPLES]}" = "n" ]]; then
+	echo "ERROR: --with-fio and --disable-examples are mutually exclusive."
+	exit 1
+fi
+
 if [[ $sys_name == "FreeBSD" ]]; then
 	# FreeBSD doesn't support all configurations
 	if [[ "${CONFIG[COVERAGE]}" == "y" ]]; then
@@ -645,6 +803,16 @@ if [[ $sys_name == "FreeBSD" ]]; then
 	fi
 fi
 
+if [[ $sys_name == "Linux" ]]; then
+	if pkg-config libbsd; then
+		CONFIG[HAVE_LIBBSD]=y
+	fi
+fi
+
+if pkg-config libarchive; then
+	CONFIG[HAVE_LIBARCHIVE]=y
+fi
+
 if [[ $sys_name != "Linux" ]]; then
 	if [[ "${CONFIG[VHOST]}" == "y" ]]; then
 		echo "Vhost is only supported on Linux."
@@ -701,13 +869,26 @@ than or equal to 4.14 will see significantly reduced performance.
 		echo "RDMA_OPTION_ID_ACK_TIMEOUT is not supported"
 	fi
 
+	if echo -e '#include <rdma/rdma_cma.h>\n' \
+		'int main(void) { return !!RDMA_OPTION_ID_TOS; }\n' \
+		| "${BUILD_CMD[@]}" -c - 2> /dev/null; then
+		CONFIG[RDMA_SET_TOS]="y"
+	else
+		CONFIG[RDMA_SET_TOS]="n"
+		echo "RDMA_OPTION_ID_TOS is not supported"
+	fi
+
 	if [ "${CONFIG[RDMA_PROV]}" == "mlx5_dv" ]; then
-		if ! echo -e '#include <spdk/stdinc.h>\n' \
+		MLX5_DV_BUILD_BUILD_CMD="
-			'#include <infiniband/mlx5dv.h>\n' \
+		#include <infiniband/mlx5dv.h>\n
-			'#include <rdma/rdma_cma.h>\n' \
+		#include <rdma/rdma_cma.h>\n
-			'int main(void) { return rdma_establish(NULL) || ' \
+		int main(void) { return rdma_establish(NULL) ||\n
-			'!!IBV_QP_INIT_ATTR_SEND_OPS_FLAGS || !!MLX5_OPCODE_RDMA_WRITE; }\n' \
+		!!IBV_QP_INIT_ATTR_SEND_OPS_FLAGS || !!MLX5_OPCODE_RDMA_WRITE"
-			| "${BUILD_CMD[@]}" -lmlx5 -I${rootdir}/include -c - 2> /dev/null; then
+		if [ "${CONFIG[CRYPTO]}" = "y" ]; then
+			MLX5_DV_BUILD_BUILD_CMD+="|| !!MLX5DV_CRYPTO_ENGINES_CAP_AES_XTS_SINGLE_BLOCK"
+		fi
+		MLX5_DV_BUILD_BUILD_CMD+=";}"
+		if ! echo -e $MLX5_DV_BUILD_BUILD_CMD | "${BUILD_CMD[@]}" -lmlx5 -I${rootdir}/include -c -; then
 			echo "mlx5_dv provider is not supported"
 			exit 1
 		fi
@@ -718,76 +899,106 @@ fi
 
 if [[ "${CONFIG[FC]}" = "y" ]]; then
 	if [[ -n "${CONFIG[FC_PATH]}" ]]; then
-		if [ ! -d "${CONFIG[FC_PATH]}" ]; then
+		check_dir "${CONFIG[FC_PATH]}"
-			echo "${CONFIG[FC_PATH]}: directory not found"
-			exit 1
-		fi
 	fi
 fi
 
-if [[ "${CONFIG[ISAL]}" = "y" ]] || [[ "${CONFIG[CRYPTO]}" = "y" ]]; then
+function dpdk_version() {
-	if [[ "${HAVE_NASM}" = "n" ]] && [[ $arch == x86_64* ]]; then
+	# Check DPDK version to determine if mlx5_pci driver is supported
-		echo "ERROR: ISA-L, compression & crypto require NASM version 2.14 or newer."
+	local dpdk_ver="none"
-		echo "Please install or upgrade them re-run this script."
+	if [[ "${CONFIG[DPDK_DIR]}" == "$rootdir/dpdk/build" ]]; then
-		exit 1
+		# DPDK_DIR points at our submodule so ./build may not exist yet. Use
-	else
+		# absolute path to lookup the version.
-		if [[ "${CONFIG[CRYPTO]}" = "y" ]]; then
+		dpdk_ver=$(< "$rootdir/dpdk/VERSION")
-			CONFIG[IPSEC_MB]=y
+	elif [[ -f "${CONFIG[DPDK_DIR]}"/../VERSION ]]; then
-		fi
+		dpdk_ver=$(< "${CONFIG[DPDK_DIR]}"/../VERSION)
 	fi
-fi
+	echo $dpdk_ver
+}
 
-if [[ "${CONFIG[PMDK]}" = "y" ]]; then
+function mlx5_build() {
-	if ! echo -e '#include <libpmemblk.h>\nint main(void) { return 0; }\n' \
+	# Check if libmlx5 exists to enable mlx5_pci compress/crypto PMD
-		| "${BUILD_CMD[@]}" -lpmemblk - 2> /dev/null; then
-		echo "--with-pmdk requires libpmemblk."
-		echo "Please install then re-run this script."
-		exit 1
-	fi
-fi
-
-if [[ "${CONFIG[REDUCE]}" = "y" ]]; then
-	if ! echo -e '#include <libpmem.h>\nint main(void) { return 0; }\n' \
-		| "${BUILD_CMD[@]}" -lpmem - 2> /dev/null; then
-		echo "--with-reduce requires libpmem."
-		echo "Please install then re-run this script."
-		exit 1
-	fi
-
-	CONFIG[REDUCE_MLX5]="y"
-	# Check if libmlx5 exists to enable mlx5_pci compress PMD
 	if ! echo -e '#include <spdk/stdinc.h>\n' \
 		'#include <infiniband/mlx5dv.h>\n' \
 		'#include <infiniband/verbs.h>\n' \
 		'int main(void) { return 0; }\n' \
-		| "${BUILD_CMD[@]}" -lmlx5 -I${rootdir}/include -c - 2> /dev/null; then
+		| "${BUILD_CMD[@]}" -lmlx5 -libverbs -I${rootdir}/include -c - 2> /dev/null; then
-		echo "libmlx5 is not found, so disabling DPDK mlx5_pci compress PMD"
+		return 1
-		CONFIG[REDUCE_MLX5]="n"
 	fi
+	return 0
+}
 
-	if [[ "${CONFIG[DPDK_PKG_CONFIG]}" = "y" ]]; then
+if [[ "${CONFIG[VBDEV_COMPRESS]}" = "y" ]]; then
-		# Check if librte_compress_mlx5 exists in DPDK package
+	echo "WARNING: PMDK - Persistent device support with bdev_compress is deprecated."
-		if [ ! -f "${CONFIG[DPDK_LIB_DIR]}"/librte_compress_mlx5.so ]; then
+	if ! echo -e '#include <libpmem.h>\nint main(void) { return 0; }\n' \
-			echo "librte_compress_mlx5 is not found, so disabling DPDK mlx5_pci compress PMD"
+		| "${BUILD_CMD[@]}" -lpmem - 2> /dev/null; then
-			CONFIG[REDUCE_MLX5]="n"
+		echo "--with-vbdev-compress requires libpmem."
-		fi
+		echo "Please install then re-run this script."
+		exit 1
+	fi
+	# Try to enable mlx5 compress
+	CONFIG[VBDEV_COMPRESS_MLX5]="y"
+
+	# Check if libmlx5 exists to enable mlx5_pci compress PMD
+	if ! mlx5_build; then
+		echo "libmlx5 is not found, so disabling DPDK mlx5_pci compress PMD"
+		CONFIG[VBDEV_COMPRESS_MLX5]="n"
 	else
-		# Check DPDK version to determine if mlx5_pci driver is supported
+		if [[ "${CONFIG[DPDK_PKG_CONFIG]}" = "y" ]]; then
-		dpdk_ver=""
+			# Check if librte_compress_mlx5 exists in DPDK package
-		if [[ "${CONFIG[DPDK_DIR]}" == "$rootdir/dpdk/build" ]]; then
+			if [ ! -f "${CONFIG[DPDK_LIB_DIR]}"/librte_compress_mlx5.so ]; then
-			# DPDK_DIR points at our submodule so ./build may not exist yet. Use
+				echo "librte_compress_mlx5 is not found, so disabling DPDK mlx5_pci compress PMD"
-			# absolute path to lookup the version.
+				CONFIG[VBDEV_COMPRESS_MLX5]="n"
-			dpdk_ver=$(< "$rootdir/dpdk/VERSION")
+			fi
-		elif [[ -f "${CONFIG[DPDK_DIR]}"/../VERSION ]]; then
-			dpdk_ver=$(< "${CONFIG[DPDK_DIR]}"/../VERSION)
 		else
-			echo "Cannot get DPDK version, so disabling DPDK mlx5_pci compress PMD"
+			# Check DPDK version to determine if mlx5_pci driver is supported
-			CONFIG[REDUCE_MLX5]="n"
+			dpdk_ver=$(dpdk_version)
+			if [[ $dpdk_ver = "none" ]]; then
+				echo "Cannot get DPDK version, so disabling DPDK mlx5_pci compress PMD"
+				CONFIG[VBDEV_COMPRESS_MLX5]="n"
+			elif [[ -n $dpdk_ver ]] && lt "$dpdk_ver" 21.02.0; then
+				# mlx5_pci for compress is supported by DPDK >- 21.02.0
+				echo "DPDK version ${dpdk_ver} doesn't support mlx5_pci compress PMD"
+				CONFIG[VBDEV_COMPRESS_MLX5]="n"
+			elif [[ -n ${CONFIG[DPDK_LIB_DIR]} ]] && [ ! -f "${CONFIG[DPDK_LIB_DIR]}"/librte_compress_mlx5.so ]; then
+				# This is only checked when --with-dpdk or --with-dpdk=* is used
+				echo "librte_compress_mlx5 is not found, so disabling DPDK mlx5_pci compress PMD"
+				CONFIG[VBDEV_COMPRESS_MLX5]="n"
+			fi
 		fi
-		# mlx5_pci is supported by DPDK >- 21.02.0
+	fi
-		if [[ -n $dpdk_ver ]] && lt "$dpdk_ver" 21.02.0; then
+fi
-			echo "DPDK version ${dpdk_ver} doesn't support mlx5_pci compress PMD"
+
-			CONFIG[REDUCE_MLX5]="n"
+if [[ "${CONFIG[CRYPTO]}" = "y" ]]; then
+	# Try to enable mlx5 crypto
+	CONFIG[CRYPTO_MLX5]="y"
+
+	# Check if libmlx5 exists to enable mlx5_pci compress PMD
+	if ! mlx5_build; then
+		echo "libmlx5 is not found, so disabling DPDK mlx5_pci crypto PMD"
+		CONFIG[CRYPTO_MLX5]="n"
+	else
+		if [[ "${CONFIG[DPDK_PKG_CONFIG]}" = "y" ]]; then
+			# Check if librte_crypto_mlx5 exists in DPDK package
+			if [ ! -f "${CONFIG[DPDK_LIB_DIR]}"/librte_crypto_mlx5.so ]; then
+				echo "librte_crypto_mlx5 is not found, so disabling DPDK mlx5_pci crypto PMD"
+				CONFIG[CRYPTO_MLX5]="n"
+			fi
+		else
+			# Check DPDK version to determine if mlx5_pci driver is supported
+			dpdk_ver=$(dpdk_version)
+			if [[ $dpdk_ver = "none" ]]; then
+				echo "Cannot get DPDK version, so disabling DPDK mlx5_pci crypto PMD"
+				CONFIG[CRYPTO_MLX5]="n"
+			elif [[ -n $dpdk_ver ]] && lt "$dpdk_ver" 21.11.0; then
+				# mlx5_pci for crypto is supported by DPDK >- 21.11.0
+				echo "DPDK version ${dpdk_ver} doesn't support mlx5_pci crypto PMD"
+				CONFIG[CRYPTO_MLX5]="n"
+			elif [[ -n ${CONFIG[DPDK_LIB_DIR]} ]] && [ ! -f "${CONFIG[DPDK_LIB_DIR]}"/librte_crypto_mlx5.so ]; then
+				# This is only checked when --with-dpdk or --with-dpdk=* is used
+				echo "librte_crypto_mlx5 is not found, so disabling DPDK mlx5_pci crypto PMD"
+				CONFIG[CRYPTO_MLX5]="n"
+			fi
 		fi
 	fi
 fi
@@ -811,6 +1022,16 @@ if [[ "${CONFIG[RBD]}" = "y" ]]; then
 	fi
 fi
 
+if [[ "${CONFIG[UBLK]}" = "y" ]]; then
+	if ! echo -e '#include <linux/ublk_cmd.h>\n#include <liburing.h>\n' \
+		'int main(void) { return 0; }\n' \
+		| "${BUILD_CMD[@]}" -luring - 2> /dev/null; then
+		echo "--with-ublk requires liburing and ublk_drv."
+		echo "Please install then re-run this script."
+		exit 1
+	fi
+fi
+
 if [[ "${CONFIG[ISCSI_INITIATOR]}" = "y" ]]; then
 	# Fedora installs libiscsi to /usr/lib64/iscsi for some reason.
 	if ! echo -e '#include <iscsi/iscsi.h>\n#include <iscsi/scsi-lowlevel.h>\n' \
@@ -826,6 +1047,20 @@ if [[ "${CONFIG[ISCSI_INITIATOR]}" = "y" ]]; then
 	fi
 fi
 
+if [[ "${CONFIG[DAOS]}" = "y" ]]; then
+	daos_build_cmd=("${BUILD_CMD[@]}")
+	if [[ -n "${CONFIG[DAOS_DIR]}" ]]; then
+		daos_build_cmd+=(-I"${CONFIG[DAOS_DIR]}"/include -L"${CONFIG[DAOS_DIR]}"/lib64)
+	fi
+	if ! echo -e '#include <daos.h>\n#include <daos_fs.h>\n' \
+		'int main(void) { return 0; }\n' \
+		| "${daos_build_cmd[@]}" -lgurt -ldaos -ldaos_common -ldfs - 2> /dev/null; then
+		echo "--with-daos requires libdaos, libdaos_common, libdfs and libgurt"
+		echo "Please install then re-run this script."
+		exit 1
+	fi
+fi
+
 if [[ "${CONFIG[ASAN]}" = "y" ]]; then
 	if ! echo -e 'int main(void) { return 0; }\n' \
 		| "${BUILD_CMD[@]}" -fsanitize=address - 2> /dev/null; then
@@ -855,6 +1090,16 @@ if [[ "${CONFIG[TSAN]}" = "y" ]]; then
 	fi
 fi
 
+if echo -e '#include <stdlib.h>\nint main(void) { arc4random(); return 0; }\n' \
+	| "${BUILD_CMD[@]}" - 2> /dev/null; then
+	CONFIG[HAVE_ARC4RANDOM]="y"
+fi
+
+if echo -e '#include <uuid/uuid.h>\nint main(void) { uuid_generate_sha1(NULL, NULL, NULL, 0); return 0; }\n' \
+	| "${BUILD_CMD[@]}" - -luuid 2> /dev/null; then
+	CONFIG[HAVE_UUID_GENERATE_SHA1]="y"
+fi
+
 if [[ "${CONFIG[OCF]}" = "y" ]]; then
 	# If OCF_PATH is a file, assume it is a library and use it to compile with
 	if [ -f ${CONFIG[OCF_PATH]} ]; then
@@ -875,18 +1120,23 @@ elif [[ "${CONFIG[PGO_USE]}" = "y" ]]; then
 	fi
 fi
 
-if [[ "${CONFIG[URING]}" = "y" ]]; then
+if [[ "${CONFIG[URING]}" = "y" || "${CONFIG[XNVME]}" = "y" ]]; then
 	if [[ -n "${CONFIG[URING_PATH]}" ]]; then
-		if [ ! -d "${CONFIG[URING_PATH]}" ]; then
+		check_dir "${CONFIG[URING_PATH]}"
-			echo "${CONFIG[URING_PATH]}: directory not found"
-			exit 1
-		fi
 	elif ! echo -e '#include <liburing.h>\nint main(void) { return 0; }\n' \
 		| "${BUILD_CMD[@]}" -luring - 2> /dev/null; then
 		echo "--with-uring requires liburing."
 		echo "Please build and install then re-run this script."
 		exit 1
 	fi
+	# Support for Zoned devices is enabled by default for Uring bdev. Check appropriate support in kernel.
+	if [[ "${CONFIG[URING_ZNS]}" = "y" ]]; then
+		if ! echo -e '#include<linux/blkzoned.h>\nint main(void) { return BLK_ZONE_REP_CAPACITY; }\n' \
+			| "${BUILD_CMD[@]}" -c - 2> /dev/null; then
+			echo "Disabling Zoned NS support in Uring! Requires blkzoned.h from kernel >= linux-5.9."
+			CONFIG[URING_ZNS]=n
+		fi
+	fi
 fi
 
 if [[ "${CONFIG[FUSE]}" = "y" ]]; then
@@ -910,13 +1160,45 @@ if [[ "${CONFIG[FUZZER]}" = "y" && "$CC_TYPE" != "clang" ]]; then
 	exit 1
 fi
 
-if [[ "${CONFIG[ISAL]}" = "y" ]]; then
+if [[ $arch == x86_64* ]] || [[ $arch == aarch64* ]]; then
+	CONFIG[ISAL]=y
+	# make sure the submodule is initialized
 	if [ ! -f "$rootdir"/isa-l/autogen.sh ]; then
-		echo "ISA-L was not found; To install ISA-L run:"
+		echo "ISA-L is required but was not found, please init the submodule with:"
 		echo "  git submodule update --init"
+		echo "and then re-run this script."
 		exit 1
 	fi
+	# for x86 only, check the nasm version for ISA-L and IPSEC
+	if [[ $arch == x86_64* ]]; then
+		ver=$(nasm -v 2> /dev/null | awk '{print $3}' | awk -Fr '{print $1}')
+		if lt "$ver" 2.14; then
+			CONFIG[ISAL]=n
+			# IPSEC has nasm requirement and DPDK crypto relies on IPSEC
+			CONFIG[IPSEC_MB]=n
+			echo "WARNING: ISA-L & DPDK crypto cannot be used as nasm ver must be 2.14 or newer."
+		fi
+	fi
+	# check gas version on aarch64
+	if [[ $arch == aarch64* ]]; then
+		ver=$(as --version 2> /dev/null | awk 'NR==1{print $7}')
+		if lt "$ver" 2.24; then
+			# ISA-L, compression & crypto require gas version 2.24 or newer.
+			CONFIG[ISAL]=n
+			echo "Notice: ISA-L, compression & crypto require GAS version 2.24 or newer. Turning off default ISA-L and crypto features."
+		elif lt "$ver" 2.34; then
+			#For gas v2.24~v2.34, sve2 instructions are not supported. To workaround it, sve2 optimization should be disabled
+			ISAL_CRYPTO_OPTS+=("--disable-sve2")
+		fi
+	fi
+else
+	# for PPC
+	CONFIG[ISAL]=n
+	echo "WARNING: ISA-L cannot be used due to architecture incompatibility."
+fi
 
+# now either configure ISA-L or disable unavailable features
+if [[ "${CONFIG[ISAL]}" = "y" ]]; then
 	cd $rootdir/isa-l
 	ISAL_LOG=$rootdir/isa-l/spdk-isal.log
 	if [[ -n "${CONFIG[CROSS_PREFIX]}" ]]; then
@@ -929,6 +1211,62 @@ if [[ "${CONFIG[ISAL]}" = "y" ]]; then
 	./configure CFLAGS="-fPIC -g -O2" "${ISAL_OPTS[@]}" --enable-shared=no >> $ISAL_LOG 2>&1
 	echo "done."
 	cd $rootdir
+else
+	echo "Without ISA-L, there is no software support for crypto or compression,"
+	echo "so these features will be disabled."
+	CONFIG[CRYPTO]=n
+	CONFIG[VBDEV_COMPRESS]=n
+	CONFIG[DPDK_COMPRESSDEV]=n
+fi
+
+# ISA-L-crypto complements ISA-L functionality, it is only enabled together with ISA-L
+if [[ "${CONFIG[ISAL]}" = "y" ]]; then
+	if [ ! -f "$rootdir"/isa-l-crypto/autogen.sh ]; then
+		echo "ISA-L-crypto is required but was not found, please init the submodule with:"
+		echo "  git submodule update --init"
+		echo "and then re-run this script."
+		exit 1
+	fi
+
+	cd $rootdir/isa-l-crypto
+	ISAL_CRYPTO_LOG=$rootdir/isa-l-crypto/spdk-isal-crypto.log
+	if [[ -n "${CONFIG[CROSS_PREFIX]}" ]]; then
+		ISAL_CRYPTO_OPTS+=("--host=${CONFIG[CROSS_PREFIX]}")
+	fi
+	ISAL_CRYPTO_OPTS+=("--enable-shared=no")
+	echo -n "Configuring ISA-L-crypto (logfile: $ISAL_CRYPTO_LOG)..."
+	./autogen.sh &> $ISAL_CRYPTO_LOG
+	./configure CFLAGS="-fPIC -g -O2" "${ISAL_CRYPTO_OPTS[@]}" >> $ISAL_CRYPTO_LOG 2>&1
+	echo "done."
+	cd $rootdir
+	CONFIG[ISAL_CRYPTO]=y
+else
+	CONFIG[ISAL_CRYPTO]=n
+fi
+
+if [[ "${CONFIG[SMA]}" = "y" ]]; then
+	if ! python3 -c 'import grpc; import grpc_tools' 2> /dev/null; then
+		echo "--with-sma requires grpcio and grpcio-tools python packages."
+		echo "Please install then re-run this script."
+		exit 1
+	fi
+fi
+
+if [[ "${CONFIG[AVAHI]}" = "y" ]]; then
+	if ! echo -e '#include <avahi-client/client.h>\n#include <avahi-common/malloc.h>\n' \
+		'int main(void) { return 0; }\n' \
+		| "${BUILD_CMD[@]}" -lavahi-client -lavahi-common - 2> /dev/null; then
+		echo "--with-avahi requires libavahi-client and libavahi-common."
+		echo "Please install then re-run this script."
+		exit 1
+	fi
+fi
+
+if [[ -n ${CONFIG[MAX_LCORES]} ]]; then
+	if [[ ! ${CONFIG[MAX_LCORES]} =~ ^([1-9][0-9]*|detect)$ ]] || ((CONFIG[MAX_LCORES] > 1024)); then
+		echo "ERROR: Max number of lcores must be a decimal number in range [1..1024] or 'detect' (given: ${CONFIG[MAX_LCORES]})"
+		exit 1
+	fi
 fi
 
 # For ARM Neoverse-N1 platform, debug build needs gcc version newer than 8.4
@@ -941,6 +1279,10 @@ if [[ "${CONFIG[DEBUG]}" = "y" && $arch = aarch64* && "$CC_TYPE" = "gcc" ]]; the
 			echo "WARNING: For ARM Neoverse-N1 platform, debug build needs GCC version newer than 8.4."
 			echo "         Will work around this by using armv8.2-a+crypto as target architecture for now."
 			CONFIG[ARCH]=armv8.2-a+crypto
+		elif [[ $PART_NUM = 0x0b2 ]]; then
+			echo "WARNING: For ARM octeontx2 platform, debug build needs GCC version newer than 8.4."
+			echo "         Will work around this by using armv8.2-a+crypto as target architecture for now."
+			CONFIG[ARCH]=armv8.2-a+crypto
 		fi
 	fi
 fi
@@ -959,6 +1301,8 @@ fi
 
 echo -n "Creating mk/config.mk..."
 cp -f $rootdir/CONFIG $rootdir/mk/config.mk
+ARGS=$(echo "$@" | sed 's/ /\\ /g')
+sed -i.bak -r "s#__CONFIGURE_OPTIONS__#${ARGS}#g" $rootdir/mk/config.mk
 for key in "${!CONFIG[@]}"; do
 	sed -i.bak -r "s#[[:space:]]*CONFIG_${key}=.*#CONFIG_${key}\?=${CONFIG[$key]}#g" $rootdir/mk/config.mk
 done

deprecation.md

@@ -1,6 +1,6 @@
 # Deprecation
 
-## ABI and API Deprecation {#deprecation}
+## ABI and API Deprecation
 
 This document details the policy for maintaining stability of SPDK ABI and API.
 
@@ -12,15 +12,51 @@ Each entry must describe what will be removed and can suggest the future use or
 Specific future SPDK release for the removal must be provided.
 ABI cannot be removed without providing deprecation notice for at least single SPDK release.
 
-## Deprecation Notices {#deprecation-notices}
+Deprecated code paths must be registered with `SPDK_DEPRECATION_REGISTER()` and logged with
+`SPDK_LOG_DEPRECATED()`. The tag used with these macros will appear in the SPDK
+log at the warn level when `SPDK_LOG_DEPRECATED()` is called, subject to rate limits.
+The tags can be matched with the level 4 headers below.
 
-### bdev
+## Deprecation Notices
 
-Deprecated `spdk_bdev_module_finish_done()` API, which will be removed in SPDK 22.01.
+### PMDK
-Bdev modules should use `spdk_bdev_module_fini_done()` instead.
 
-### nvme
+PMDK is no longer supported and integrations with it in SPDK are now deprecated, and will be removed in SPDK 23.05.
+Please see: [UPDATE ON PMDK AND OUR LONG TERM SUPPORT STRATEGY](https://pmem.io/blog/2022/11/update-on-pmdk-and-our-long-term-support-strategy/).
 
-Deprecated `spdk_nvme_ctrlr_reset_async` and `spdk_nvme_ctrlr_reset_poll_async` APIs,
+### VTune
-which will be removed in SPDK 22.01. `spdk_nvme_ctrlr_disconnect`, `spdk_nvme_ctrlr_reconnect_async`,
+
-and `spdk_nvme_ctrlr_reconnect_poll_async` should be used instead.
+#### `vtune_support`
+
+VTune integration is in now deprecated and will be removed in SPDK 23.05.
+
+### nvmf
+
+#### `spdk_nvmf_qpair_disconnect`
+
+Parameters `cb_fn` and `ctx` of `spdk_nvmf_qpair_disconnect` API are deprecated. These parameters
+will be removed in 23.09 release.
+
+### gpt
+
+#### `old_gpt_guid`
+
+Deprecated the SPDK partition type GUID `7c5222bd-8f5d-4087-9c00-bf9843c7b58c`. Partitions of this
+type have bdevs created that are one block less than the actual size of the partition. Existing
+partitions using the deprecated GUID can continue to use that GUID; support for the deprecated GUID
+will remain in SPDK indefinitely, and will continue to exhibit the off-by-one bug so that on-disk
+metadata layouts based on the incorrect size are not affected.
+
+See GitHub issue [2801](https://github.com/spdk/spdk/issues/2801) for additional details on the bug.
+
+New SPDK partition types should use GUID `6527994e-2c5a-4eec-9613-8f5944074e8b` which will create
+a bdev of the correct size.
+
+### lvol
+
+#### `vbdev_lvol_rpc_req_size`
+
+Param `size` in rpc commands `rpc_bdev_lvol_create` and `rpc_bdev_lvol_resize` is deprecated and
+replace by `size_in_mib`.
+
+See GitHub issue [2346](https://github.com/spdk/spdk/issues/2346) for additional details.

doc/.gitignore

@@ -1,3 +1,4 @@
-# changelog.md is generated by Makefile
+# changelog.md and deprecation.md is generated by Makefile
 changelog.md
+deprecation.md
 output/

doc/Doxyfile

@@ -813,7 +813,7 @@ INPUT                  += \
                          compression.md \
                          concurrency.md \
                          containers.md \
-                         ../deprecation.md \
+                         deprecation.md \
                          distributions.md \
                          event.md \
                          ftl.md \
@@ -829,10 +829,12 @@ INPUT                  += \
                          memory.md \
                          notify.md \
                          nvme.md \
+                         nvme_multipath.md \
                          nvme_spec.md \
                          nvmf.md \
                          nvmf_tgt_pg.md \
                          nvmf_tracing.md \
+                         nvmf_multipath_howto.md \
                          overview.md \
                          peer_2_peer.md \
                          pkgconfig.md \
@@ -840,10 +842,12 @@ INPUT                  += \
                          rpm.md \
                          scheduler.md \
                          shfmt.md \
+                         sma.md \
                          spdkcli.md \
                          spdk_top.md \
                          ssd_internals.md \
                          system_configuration.md \
+                         ublk.md \
                          usdt.md \
                          userspace.md \
                          vagrant.md \
@@ -1243,7 +1247,7 @@ HTML_COLORSTYLE_GAMMA  = 80
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
-HTML_TIMESTAMP         = YES
+HTML_TIMESTAMP         = NO
 
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
@@ -1515,17 +1519,6 @@ EXT_LINKS_IN_WINDOW    = NO
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
 # http://www.mathjax.org) which uses client side Javascript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
@@ -1804,16 +1797,6 @@ LATEX_BATCHMODE        = YES
 
 LATEX_HIDE_INDICES     = NO
 
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
 # http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
@@ -1886,16 +1869,6 @@ RTF_STYLESHEET_FILE    =
 
 RTF_EXTENSIONS_FILE    =
 
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
 #---------------------------------------------------------------------------
 # Configuration options related to the man page output
 #---------------------------------------------------------------------------
@@ -1985,15 +1958,6 @@ GENERATE_DOCBOOK       = NO
 
 DOCBOOK_OUTPUT         = docbook
 
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
 #---------------------------------------------------------------------------
 # Configuration options for the AutoGen Definitions output
 #---------------------------------------------------------------------------
@@ -2178,15 +2142,6 @@ EXTERNAL_PAGES         = YES
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
 
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
 # You can define message sequence charts within doxygen comments using the \msc
 # command. Doxygen will then run the mscgen tool (see:
 # http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
@@ -2228,23 +2183,6 @@ HAVE_DOT               = YES
 
 DOT_NUM_THREADS        = 0
 
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
 # By default doxygen will tell dot to use the default font as specified with
 # DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
 # the path where dot can find it using this tag.
@@ -2457,18 +2395,6 @@ DOT_GRAPH_MAX_NODES    = 50
 
 MAX_DOT_GRAPH_DEPTH    = 2
 
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
 # Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
 # files in one run (i.e. multiple -o and -T options on the command line). This
 # makes dot run faster, but since only newer versions of dot (>1.8.10) support

doc/Makefile

@@ -1,3 +1,8 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2015 Intel Corporation
+#  All rights reserved.
+#
+
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
@@ -8,6 +13,10 @@ all: doc
 
 doc: output
 
+deprecation.md: ../deprecation.md
+	$(Q)sed -e 's/^# Deprecation/# Deprecation {#deprecation}/' \
+	    < $< > $@
+
 changelog.md: ../CHANGELOG.md
 	$(Q)sed -e 's/^# Changelog/# Changelog {#changelog}/' \
 	    -e 's/^##/#/' \
@@ -15,9 +24,9 @@ changelog.md: ../CHANGELOG.md
 	    -e '/# v..\...:/s/\./-/2' \
 	    < $< > $@
 
-output: Doxyfile changelog.md $(wildcard *.md) $(wildcard ../include/spdk/*.h)
+output: Doxyfile changelog.md deprecation.md $(wildcard *.md) $(wildcard ../include/spdk/*.h)
 	$(Q)rm -rf $@
 	$(Q)doxygen Doxyfile
 
 clean:
-	$(Q)rm -rf output changelog.md
+	$(Q)rm -rf output changelog.md deprecation.md

doc/accel_fw.md

@@ -9,31 +9,27 @@ exists to enable use of the framework in environments without hardware
 acceleration capabilities. ISA/L is used for optimized CRC32C calculation within
 the software module.
 
-The framework includes an API for getting the current capabilities of the
-selected module. See [`spdk_accel_get_capabilities`](https://spdk.io/doc/accel__engine_8h.html) for more details.
-For the software module, all capabilities will be reported as supported. For the hardware modules, only functions
-accelerated by hardware will be reported however any function can still be called, it will just be backed by
-software if it is not reported as a supported capability.
-
 ## Acceleration Framework Functions {#accel_functions}
 
 Functions implemented via the framework can be found in the DoxyGen documentation of the
-framework public header file here [accel_engine.h](https://spdk.io/doc/accel__engine_8h.html)
+framework public header file here [accel.h](https://spdk.io/doc/accel_8h.html)
 
 ## Acceleration Framework Design Considerations {#accel_dc}
 
-The general interface is defined by `/include/accel_engine.h` and implemented
+The general interface is defined by `/include/spdk/accel.h` and implemented
 in `/lib/accel`.  These functions may be called by an SPDK application and in
 most cases, except where otherwise documented, are asynchronous and follow the
 standard SPDK model for callbacks with a callback argument.
 
 If the acceleration framework is started without initializing a hardware module,
-optimized software implementations of the functions will back the public API.
+optimized software implementations of the operations will back the public API. All
-Additionally, if any hardware module does not support a specific function and that
+operations supported by the framework have a backing software implementation in
-hardware module is initialized, the specific function will fallback to a software
+the event that no hardware accelerators have been enabled for that operation.
-optimized implementation.  For example, IOAT does not support the dualcast function
+
-in hardware but if the IOAT module has been initialized and the public dualcast API
+When multiple hardware modules are enabled the framework will assign each operation to
-is called, it will actually be done via software behind the scenes.
+a module based on the order in which it was initialized. So, for example if two modules are
+enabled, IOAT and software, the software module will be used for every operation except those
+supported by IOAT.
 
 ## Acceleration Low Level Libraries {#accel_libs}
 
@@ -49,18 +45,18 @@ functions exposed by the individual low level libraries. Thus, code written this
 way needs to be certain that the underlying hardware exists everywhere that it runs.
 
 The low level library for IOAT is located in `/lib/ioat`.  The low level library
-for DSA is in `/lib/idxd` (IDXD stands for Intel(R) Data Acceleration Driver).
+for DSA and IAA is in `/lib/idxd` (IDXD stands for Intel(R) Data Acceleration Driver and
-In `/lib/idxd` folder, SPDK supports to leverage both user space and kernel space driver
+supports both DSA and IAA hardware accelerators). In `/lib/idxd` folder, SPDK supports the ability
-to drive DSA devices. And the following describes each usage scenario:
+to use either user space and kernel space drivers. The following describes each usage scenario:
 
-Leveraging user space idxd driver: The DSA devices are managed by the user space
+Leveraging user space idxd driver: The DSA devices are managed by the SPDK user space
 driver in a dedicated SPDK process, then the device cannot be shared by another
 process. The benefit of this usage is no kernel dependency.
 
 Leveraging kernel space driver: The DSA devices are managed by kernel
 space drivers. And the Work queues inside the DSA device can be shared among
 different processes. Naturally, it can be used in cloud native scenario. The drawback of
-this usage is the kernel dependency, i.e., idxd driver must be supported and loaded
+this usage is the kernel dependency, i.e., idxd kernel driver must be supported and loaded
 in the kernel.
 
 ## Acceleration Plug-In Modules {#accel_modules}
@@ -74,89 +70,121 @@ RPC is provided, the framework is available and will use the software plug-in mo
 
 ### IOAT Module {#accel_ioat}
 
-To use the IOAT engine, use the RPC [`ioat_scan_accel_engine`](https://spdk.io/doc/jsonrpc.html) before starting the application.
+To use the IOAT module, use the RPC [`ioat_scan_accel_module`](https://spdk.io/doc/jsonrpc.html) before starting the application.
 
-### IDXD Module {#accel_idxd}
+### DSA Module {#accel_dsa}
 
-To use the DSA engine, use the RPC [`idxd_scan_accel_engine`](https://spdk.io/doc/jsonrpc.html). With an optional parameter
+The DSA module supports the DSA hardware and relies on the low level IDXD library.
-of `-c` and providing a configuration number of either 0 or 1, users can determine which pre-defined configuration can be used.
-With an optional parameter of `-k` to use kernel or user space driver. These pre-defined configurations determine how the DSA engine
-will be setup in terms of work queues and engines.  The DSA engine is very flexible allowing for various configurations of
-these elements to either account for different quality of service requirements or to isolate hardware paths where the back
-end media is of varying latency (i.e. persistent memory vs DRAM).  The pre-defined configurations are as follows:
 
-0: A single work queue backed with four DSA engines.  This is a generic configuration
+To use the DSA module, use the RPC
-that enables the hardware to best determine which engine to use as it pulls in new
+[`dsa_scan_accel_module`](https://spdk.io/doc/jsonrpc.html). By default, this
-operations.
+will attempt to load the SPDK user-space idxd driver. To use the built-in
+kernel driver on Linux, add the `-k` parameter. See the next section for
+details on using the kernel driver.
 
-1: Two separate work queues each backed with two DSA engines. This is another
+The DSA hardware supports a limited queue depth and channels. This means that
-generic configuration that is documented in the specification and allows the
+only a limited number of `spdk_thread`s will be able to acquire a channel.
-application to partition submissions across two work queues. This would be useful
+Design software to deal with the inability to get a channel.
-when different priorities might be desired per group.
 
-There are several other configurations that are possible that include quality
+#### How to use kernel idxd driver {#accel_idxd_kernel}
-of service parameters on the work queues that are not currently utilized by
-the module. Specialized use of DSA may require different configurations that
-can be added to the module as needed.
 
-When a new channel starts, a DSA device will be assigned to the channel. The accel
+There are several dependencies to leverage the Linux idxd driver for driving DSA devices.
-idxd module has been tuned for the most likely best performance case. The result
-is that there is a limited number of channels that can be supported based on the
-number of DSA devices in the system.  Additionally, for best performance, the accel
-idxd module will only use DSA devices on the same socket as the requesting
-channel/thread.  If an error occurs on initialization indicating that there are no
-more DSA devices available either try fewer threads or, if on a 2 socket system,
-try spreading threads across cores if possible.
 
-### How to use kernel idxd driver {#accel_idxd_kernel}
+1 Linux kernel support: You need to have a Linux kernel with the `idxd` driver
+loaded. Further, add the following command line options to the kernel boot
+commands:
 
-There are several dependencies to leverage kernel idxd driver for driving DSA devices.
+```bash
+intel_iommu=on,sm_on
+```
 
-1 Linux kernel support: To leverage kernel space idxd driver, you need to have a Linux kernel with
+2 User library dependency: Users need to install the developer version of the
-`idxd` driver loaded with scalable mode. And currently SPDK uses the character device while `idxd` driver is
+`accel-config` library. This is often packaged, but the source is available on
-enabled in the kernel. So when booting the machine, we need to add additional configuration in
+[GitHub](https://github.com/intel/idxd-config). After the library is installed,
-the grub, i.e, revise the kernel boot commandline `intel_iommu=on,sm_on` with VT-d turned on in BIOS.
+users can use the `accel-config` command to configure the work queues(WQs) of
+the idxd devices managed by the kernel with the following steps:
 
-2 User library dependency: Users need to install `idxd-config` library. For example, users can
+Note: this library must be installed before you run `configure`
-download the library from [idxd-config repo](https://github.com/intel/idxd-config). After the
-library is installed, users can use the `accel-config` command to configure the work queues(WQs)
-of the idxd devices managed by the kernel with the following steps:
 
 ```bash
 accel-config disable-wq dsa0/wq0.1
 accel-config disable-device dsa0
-accel-config config-wq --group-id=0 --mode=dedicated --wq-size=16 --type=user --name="MyApp1"
+accel-config config-wq --group-id=0 --mode=dedicated --wq-size=128 --type=user --name="MyApp1"
  --priority=10 --block-on-fault=1 dsa0/wq0.1
+accel-config config-engine dsa0/engine0.0 --group-id=0
 accel-config config-engine dsa0/engine0.1 --group-id=0
+accel-config config-engine dsa0/engine0.2 --group-id=0
+accel-config config-engine dsa0/engine0.3 --group-id=0
 accel-config enable-device dsa0
 accel-config enable-wq dsa0/wq0.1
 ```
 
-For more details on the usage of `idxd-config`, please refer to
+DSA can be configured in many ways, but the above configuration is needed for use with SPDK.
-[idxd-config usage](https://github.com/intel/idxd-config/tree/master/Documentation/accfg).
+Before you can run using the kernel driver you need to make sure that the hardware is bound
+to the kernel driver and not VFIO.  By default when you run `setup.sh` DSA devices will be
+bound to VFIO.  To exclude DSA devices, pass a whitespace separated list of DSA devices BDF
+using the PCI_BLOCKED parameter as shown below.
+
+```bash
+sudo PCI_BLOCKED="0000:04:00.0 0000:05:00.0" ./setup.sh
+```
+
+Note: you might need to run `sudo ./setup.sh reset` to unbind all drivers before performing
+the step above.
 
 ### Software Module {#accel_sw}
 
-The software module is enabled by default. If no hardware engine is explicitly
+The software module is enabled by default. If no hardware module is explicitly
 enabled via startup RPC as discussed earlier, the software module will use ISA-L
 if available for functions such as CRC32C. Otherwise, standard glibc calls are
 used to back the framework API.
 
-### Batching {#batching}
+### dpdk_cryptodev {#accel_dpdk_cryptodev}
 
-Batching is exposed by the acceleration framework and provides an interface to
+The dpdk_cryptodev module uses DPDK CryptoDev API to implement crypto operations.
-batch sets of commands up and then submit them with a single command.  The public
+The following ciphers and PMDs are supported:
-API is consistent with the implementation however each plug-in module behaves
-differently depending on its capabilities.
 
-The DSA engine has complete support for batching all supported commands together
+- AESN-NI Multi Buffer Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES128_CBC
-into one submission. This is advantageous as it reduces the overhead incurred in
+- Intel(R) QuickAssist (QAT) Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES128_CBC,
-the submission process to the hardware.
+  RTE_CRYPTO_CIPHER_AES128_XTS
+  (Note: QAT is functional however is marked as experimental until the hardware has
+  been fully integrated with the SPDK CI system.)
+- MLX5 Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES256_XTS, RTE_CRYPTO_CIPHER_AES512_XTS
 
-The software engine supports batching only to be consistent with the framework API.
+To enable this module, use [`dpdk_cryptodev_scan_accel_module`](https://spdk.io/doc/jsonrpc.html),
-In software there is no savings by batching sets of commands versus submitting them
+this RPC is available in STARTUP state and the SPDK application needs to be run with `--wait-for-rpc`
-individually.
+CLI parameter. To select a specific PMD, use [`dpdk_cryptodev_set_driver`](https://spdk.io/doc/jsonrpc.html)
 
-The IOAT engine supports batching but it is only beneficial for `memmove` and `memfill`
+### Module to Operation Code Assignment {#accel_assignments}
-as these are supported by the hardware.  All other commands can be batched and the
+
-framework will manage all other commands via software.
+When multiple modules are initialized, the accel framework will assign op codes to
+modules by first assigning all op codes to the Software Module and then overriding
+op code assignments to Hardware Modules in the order in which they were initialized.
+The RPC `accel_get_opc_assignments` can be used at any time to see the current
+assignment map including the names of valid operations.  The RPC `accel_assign_opc`
+can be used after initializing the desired Hardware Modules but before starting the
+framework in the event that a specific override is desired.  Note that to start an
+application and send startup RPC's use the `--wait-for-rpc` parameter and then use the
+`framework_start_init` RPC to continue. For example, assume the DSA Module is initialized
+but for some reason the desire is to have the Software Module handle copies instead.
+The following RPCs would accomplish the copy override:
+
+```bash
+./scripts/rpc.py dsa_scan_accel_module
+./scripts/rpc.py accel_assign_opc -o copy -m software
+./scripts/rpc.py framework_start_init
+./scripts/rpc.py accel_get_opc_assignments
+{
+  "copy": "software",
+  "fill": "dsa",
+  "dualcast": "dsa",
+  "compare": "dsa",
+  "crc32c": "dsa",
+  "copy_crc32c": "dsa",
+  "compress": "software",
+  "decompress": "software"
+}
+```
+
+To determine the name of available modules and their supported operations use the
+RPC `accel_get_module_info`.

doc/applications.md

@@ -29,7 +29,7 @@ Param    | Long Param             | Type     | Default                | Descript
 -------- | ---------------------- | -------- | ---------------------- | -----------
 -c       | --config               | string   |                        | @ref cmd_arg_config_file
 -d       | --limit-coredump       | flag     | false                  | @ref cmd_arg_limit_coredump
--e       | --tpoint-group-mask    | integer  | 0x0                    | @ref cmd_arg_limit_tpoint_group_mask
+-e       | --tpoint-group         | integer  |                        | @ref cmd_arg_limit_tpoint_group_mask
 -g       | --single-file-segments | flag     |                        | @ref cmd_arg_single_file_segments
 -h       | --help                 | flag     |                        | show all available parameters and exit
 -i       | --shm-id               | integer  |                        | @ref cmd_arg_multi_process
@@ -61,7 +61,7 @@ to RLIM_INFINITY.  Specifying `--limit-coredump` will not set the resource limit
 
 SPDK has an experimental low overhead tracing framework.  Tracepoints in this
 framework are organized into tracepoint groups.  By default, all tracepoint
-groups are disabled.  `--tpoint-group-mask` can be used to enable a specific
+groups are disabled.  `--tpoint-group` can be used to enable a specific
 subset of tracepoint groups in the application.
 
 Note: Additional documentation on the tracepoint framework is in progress.

doc/bdev.md

@@ -52,13 +52,38 @@ with detailed information can be found on the @ref jsonrpc_components_bdev page.
 The SPDK RBD bdev driver provides SPDK block layer access to Ceph RADOS block
 devices (RBD). Ceph RBD devices are accessed via librbd and librados libraries
 to access the RADOS block device exported by Ceph. To create Ceph bdev RPC
-command `bdev_rbd_create` should be used.
+command `bdev_rbd_register_cluster` and `bdev_rbd_create` should be used.
+
+SPDK provides two ways of creating a RBD bdev. One is to create a new Rados cluster object
+for each RBD bdev. Another is to share the same Rados cluster object for multiple RBD bdevs.
+Each Rados cluster object creates a small number of io_context_pool and messenger threads.
+Ceph commands `ceph config help librados_thread_count` and `ceph config help ms_async_op_threads`
+could help to check these threads information. Besides, you can specify the number of threads by
+updating ceph.conf file or using Ceph config commands. For more information, please refer to
+[Ceph configuration](https://docs.ceph.com/en/latest/rados/configuration/ceph-conf/)
+One set of threads may not be enough to maximize performance with a large number of RBD bdevs,
+but one set of threads per RBD bdev may add too much context switching. Therefore, performance
+tuning on the number of RBD bdevs per cluster object and thread may be required.
 
 Example command
 
-`rpc.py bdev_rbd_create rbd foo 512`
+`rpc.py bdev_rbd_register_cluster rbd_cluster`
+
+This command will register a cluster named rbd_cluster. Optional `--config-file` and
+`--key-file` params are specified for the cluster.
+
+To remove a registered cluster use the bdev_rbd_unregister_cluster command.
+
+`rpc.py bdev_rbd_unregister_cluster rbd_cluster`
+
+To create RBD bdev with a registered cluster.
+
+`rpc.py bdev_rbd_create rbd foo 512 -c rbd_cluster`
 
 This command will create a bdev that represents the 'foo' image from a pool called 'rbd'.
+When specifying -c for `bdev_rbd_create`, RBD bdevs will share the same rados cluster with
+one connection of Ceph in librbd module. Instead it will create a new rados cluster with one
+cluster connection for every bdev without specifying -c.
 
 To remove a block device representation use the bdev_rbd_delete command.
 
@@ -79,15 +104,10 @@ unless the data stored on disk is placed appropriately. The compression vbdev mo
 relies on an internal SPDK library called `reduce` to accomplish this, see @ref reduce
 for detailed information.
 
-The vbdev module relies on the DPDK CompressDev Framework to provide all compression
+The compression bdev module leverages the [Acceleration Framework](https://spdk.io/doc/accel_fw.html) to
-functionality. The framework provides support for many different software only
+carry out the actual compression and decompression. The acceleration framework can be configured to use
-compression modules as well as hardware assisted support for Intel QAT. At this
+ISA-L software optimized compression or the DPDK Compressdev module for hardware acceleration. To configure
-time the vbdev module supports the DPDK drivers for ISAL, QAT and mlx5_pci.
+the Compressdev module please see the `compressdev_scan_accel_module` documentation [here](https://spdk.io/doc/jsonrpc.html)
-
-mlx5_pci driver works with BlueField 2 SmartNIC and requires additional configuration of DPDK
-environment to enable compression function. It can be done via SPDK event library by configuring
-`env_context` member of `spdk_app_opts` structure or by passing corresponding CLI arguments in the
-following form: `--allow=BDF,class=compress`, e.g. `--allow=0000:01:00.0,class=compress`.
 
 Persistent memory is used to store metadata associated with the layout of the data on the
 backing device. SPDK relies on [PMDK](http://pmem.io/pmdk/) to interface persistent memory so any hardware
@@ -110,18 +130,6 @@ created it cannot be separated from the persistent memory file that will be crea
 the specified directory.  If the persistent memory file is not available, the compression
 vbdev will also not be available.
 
-By default the vbdev module will choose the QAT driver if the hardware and drivers are
-available and loaded.  If not, it will revert to the software-only ISAL driver. By using
-the following command, the driver may be specified however this is not persistent so it
-must be done either upon creation or before the underlying logical volume is loaded to
-be honored. In the example below, `0` is telling the vbdev module to use QAT if available
-otherwise use ISAL, this is the default and if sufficient the command is not required. Passing
-a value of 1 tells the driver to use QAT and if not available then the creation or loading
-the vbdev should fail to create or load.  A value of '2' as shown below tells the module
-to use ISAL and if for some reason it is not available, the vbdev should fail to create or load.
-
-`rpc.py compress_set_pmd -p 2`
-
 To remove a compression vbdev, use the following command which will also delete the PMEM
 file.  If the logical volume is deleted the PMEM file will not be removed and the
 compression vbdev will not be available.
@@ -137,40 +145,96 @@ all volumes, if used it will return the name or an error that the device does no
 ## Crypto Virtual Bdev Module {#bdev_config_crypto}
 
 The crypto virtual bdev module can be configured to provide at rest data encryption
-for any underlying bdev. The module relies on the DPDK CryptoDev Framework to provide
+for any underlying bdev. The module relies on the SPDK Accel Framework to provide
-all cryptographic functionality. The framework provides support for many different software
+all cryptographic functionality.
-only cryptographic modules as well hardware assisted support for the Intel QAT board. The
+One of the accel modules, dpdk_cryptodev is implemented with the DPDK CryptoDev API,
-framework also provides support for cipher, hash, authentication and AEAD functions. At this
+it provides support for many different software only cryptographic modules as well hardware
-time the SPDK virtual bdev module supports cipher only as follows:
+assisted support for the Intel QAT board and NVIDIA crypto enabled NICs.
+
+For reads, the buffer provided to the crypto block device will be used as the destination buffer
+for unencrypted data.  For writes, however, a temporary scratch buffer is used as the
+destination buffer for encryption which is then passed on to the underlying bdev as the
+write buffer.  This is done to avoid encrypting the data in the original source buffer which
+may cause problems in some use cases.
+
+Below is information about accel modules which support crypto operations:
+
+### dpdk_cryptodev accel module
+
+Supports the following ciphers:
 
 - AESN-NI Multi Buffer Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES128_CBC
-- Intel(R) QuickAssist (QAT) Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES128_CBC
+- Intel(R) QuickAssist (QAT) Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES128_CBC,
+  RTE_CRYPTO_CIPHER_AES128_XTS
   (Note: QAT is functional however is marked as experimental until the hardware has
   been fully integrated with the SPDK CI system.)
+- MLX5 Crypto Poll Mode Driver: RTE_CRYPTO_CIPHER_AES256_XTS, RTE_CRYPTO_CIPHER_AES512_XTS
 
 In order to support using the bdev block offset (LBA) as the initialization vector (IV),
 the crypto module break up all I/O into crypto operations of a size equal to the block
 size of the underlying bdev.  For example, a 4K I/O to a bdev with a 512B block size,
 would result in 8 cryptographic operations.
 
-For reads, the buffer provided to the crypto module will be used as the destination buffer
+### SW accel module
-for unencrypted data.  For writes, however, a temporary scratch buffer is used as the
-destination buffer for encryption which is then passed on to the underlying bdev as the
-write buffer.  This is done to avoid encrypting the data in the original source buffer which
-may cause problems in some use cases.
 
-Example command
+Supports the following ciphers:
 
-`rpc.py bdev_crypto_create NVMe1n1 CryNvmeA crypto_aesni_mb 0123456789123456`
+- AES_XTS cipher with 128 or 256 bit keys implemented with ISA-L_crypto
 
-This command will create a crypto vbdev called 'CryNvmeA' on top of the NVMe bdev
+### General workflow
-'NVMe1n1' and will use the DPDK software driver 'crypto_aesni_mb' and the key
+
-'0123456789123456'.
+- Set desired accel module to perform crypto operations, that can be done with `accel_assign_opc` RPC command
+- Create a named crypto key using `accel_crypto_key_create` RPC command. The key will use the assigned accel
+  module. Set of parameters and supported ciphers may be different in each accel module.
+- Create virtual crypto block device providing the base block device name and the crypto key name
+  using `bdev_crypto_create` RPC command
+
+#### Example
+
+Example command which uses dpdk_cryptodev accel module
+```
+# start SPDK application with `--wait-for-rpc` parameter
+rpc.py dpdk_cryptodev_scan_accel_module
+rpc.py dpdk_cryptodev_set_driver crypto_aesni_mb
+rpc.py accel_assign_opc -o encrypt -m dpdk_cryptodev
+rpc.py accel_assign_opc -o decrypt -m dpdk_cryptodev
+rpc.py framework_start_init
+rpc.py accel_crypto_key_create -c AES_CBC -k 01234567891234560123456789123456 -n key_aesni_cbc_1
+rpc.py bdev_crypto_create NVMe1n1 CryNvmeA -n key_aesni_cbc_1
+```
+
+These commands will create a crypto vbdev called 'CryNvmeA' on top of the NVMe bdev
+'NVMe1n1' and will use a key named `key_aesni_cbc_1`. The key will work with the accel module which
+has been assigned for encrypt operations, in this example it will be the dpdk_cryptodev.
+
+### Crypto key format
+
+Please make sure the keys are provided in hexlified format. This means string passed to
+rpc.py must be twice as long than the key length in binary form.
+
+#### Example command
+
+`rpc.py accel_crypto_key_create -c AES_XTS -k2 7859243a027411e581e0c40a35c8228f -k d16a2f3a9e9f5b32daefacd7f5984f4578add84425be4a0baa489b9de8884b09 -n sample_key`
+
+This command will create a key called `sample_key`, the AES key
+'d16a2f3a9e9f5b32daefacd7f5984f4578add84425be4a0baa489b9de8884b09' and the XTS key
+'7859243a027411e581e0c40a35c8228f'. In other words, the compound AES_XTS key to be used is
+'d16a2f3a9e9f5b32daefacd7f5984f4578add84425be4a0baa489b9de8884b097859243a027411e581e0c40a35c8228f'
+
+### Delete the virtual crypto block device
 
 To remove the vbdev use the bdev_crypto_delete command.
 
 `rpc.py bdev_crypto_delete CryNvmeA`
 
+### dpdk_cryptodev mlx5_pci driver configuration
+
+The mlx5_pci driver works with crypto enabled Nvidia NICs and requires special configuration of
+DPDK environment to enable crypto function. It can be done via SPDK event library by configuring
+`env_context` member of `spdk_app_opts` structure or by passing corresponding CLI arguments in
+the following form: `--allow=BDF,class=crypto,wcs_file=/full/path/to/wrapped/credentials`, e.g.
+`--allow=0000:01:00.0,class=crypto,wcs_file=/path/credentials.txt`.
+
 ## Delay Bdev Module {#bdev_config_delay}
 
 The delay vbdev module is intended to apply a predetermined additional latency on top of a lower
@@ -210,7 +274,7 @@ possibly multiple virtual bdevs.
 
 ### SPDK GPT partition table {#bdev_ug_gpt}
 
-The SPDK partition type GUID is `7c5222bd-8f5d-4087-9c00-bf9843c7b58c`. Existing SPDK bdevs
+The SPDK partition type GUID is `6527994e-2c5a-4eec-9613-8f5944074e8b`. Existing SPDK bdevs
 can be exposed as Linux block devices via NBD and then can be partitioned with
 standard partitioning tools. After partitioning, the bdevs will need to be deleted and
 attached again for the GPT bdev module to see any changes. NBD kernel module must be
@@ -248,7 +312,7 @@ parted -s /dev/nbd0 mkpart MyPartition '0%' '50%'
 
 # Change the partition type to the SPDK GUID.
 # sgdisk is part of the gdisk package.
-sgdisk -t 1:7c5222bd-8f5d-4087-9c00-bf9843c7b58c /dev/nbd0
+sgdisk -t 1:6527994e-2c5a-4eec-9613-8f5944074e8b /dev/nbd0
 
 # Stop the NBD device (stop exporting /dev/nbd0).
 rpc.py nbd_stop_disk /dev/nbd0
@@ -373,6 +437,9 @@ To remove an NVMe controller use the bdev_nvme_detach_controller command.
 
 This command will remove NVMe bdev named Nvme0.
 
+The SPDK NVMe bdev driver provides the multipath feature. Please refer to
+@ref nvme_multipath for details.
+
 ### NVMe bdev character device {#bdev_config_nvme_cuse}
 
 This feature is considered as experimental. You must configure with --with-nvme-cuse
@@ -380,7 +447,7 @@ option to enable this RPC.
 
 Example commands
 
-`rpc.py bdev_nvme_cuse_register -n Nvme3
+`rpc.py bdev_nvme_cuse_register -n Nvme3`
 
 This command will register a character device under /dev/spdk associated with Nvme3
 controller. If there are namespaces created on Nvme3 controller, a namespace
@@ -466,50 +533,14 @@ Example commands
 
 `rpc.py bdev_passthru_delete pt`
 
-## Pmem {#bdev_config_pmem}
-
-The SPDK pmem bdev driver uses pmemblk pool as the target for block I/O operations. For
-details on Pmem memory please refer to PMDK documentation on http://pmem.io website.
-First, user needs to configure SPDK to include PMDK support:
-
-`configure --with-pmdk`
-
-To create pmemblk pool for use with SPDK user should use `bdev_pmem_create_pool` RPC command.
-
-Example command
-
-`rpc.py bdev_pmem_create_pool /path/to/pmem_pool 25 4096`
-
-To get information on created pmem pool file user can use `bdev_pmem_get_pool_info` RPC command.
-
-Example command
-
-`rpc.py bdev_pmem_get_pool_info /path/to/pmem_pool`
-
-To remove pmem pool file user can use `bdev_pmem_delete_pool` RPC command.
-
-Example command
-
-`rpc.py bdev_pmem_delete_pool /path/to/pmem_pool`
-
-To create bdev based on pmemblk pool file user should use `bdev_pmem_create` RPC
-command.
-
-Example command
-
-`rpc.py bdev_pmem_create /path/to/pmem_pool -n pmem`
-
-To remove a block device representation use the bdev_pmem_delete command.
-
-`rpc.py bdev_pmem_delete pmem`
-
 ## RAID {#bdev_ug_raid}
 
 RAID virtual bdev module provides functionality to combine any SPDK bdevs into
-one RAID bdev. Currently SPDK supports only RAID 0. RAID functionality does not
+one RAID bdev. Currently SPDK supports only RAID 0. RAID metadata may be stored
-store on-disk metadata on the member disks, so user must recreate the RAID
+on member disks if enabled when creating the RAID bdev, so user does not have to
-volume when restarting application. User may specify member disks to create RAID
+recreate the RAID volume when restarting application. It is not enabled by
-volume event if they do not exists yet - as the member disks are registered at
+default for backward compatibility. User may specify member disks to create
+RAID volume even if they do not exist yet - as the member disks are registered at
 a later time, the RAID module will claim them and will surface the RAID volume
 after all of the member disks are available. It is allowed to use disks of
 different sizes - the smallest disk size will be the amount of space used on
@@ -554,6 +585,10 @@ The user needs to configure SPDK to include io_uring support:
 
 `configure --with-uring`
 
+Support for zoned devices is enabled by default in uring bdev. It can be explicitly disabled as follows:
+
+`configure --with-uring --without-uring-zns`
+
 To create a uring bdev with given filename, bdev name and block size use the `bdev_uring_create` RPC.
 
 `rpc.py  bdev_uring_create /path/to/device bdev_u0 512`
@@ -562,6 +597,26 @@ To remove a uring bdev use the `bdev_uring_delete` RPC.
 
 `rpc.py bdev_uring_delete bdev_u0`
 
+## xnvme {#bdev_ug_xnvme}
+
+The xnvme bdev module issues I/O to the underlying NVMe devices through various I/O mechanisms
+such as libaio, io_uring, Asynchronous IOCTL using io_uring passthrough, POSIX aio, emulated aio etc.
+
+This module requires xNVMe library.
+For more information on xNVMe refer to [xNVMe] (https://xnvme.io/docs/latest)
+
+The user needs to configure SPDK to include xNVMe support:
+
+`configure --with-xnvme`
+
+To create a xnvme bdev with given filename, bdev name and I/O mechanism use the `bdev_xnvme_create` RPC.
+
+`rpc.py  bdev_xnvme_create /dev/ng0n1 bdev_ng0n1 io_uring_cmd`
+
+To remove a xnvme bdev use the `bdev_xnvme_delete` RPC.
+
+`rpc.py bdev_xnvme_delete bdev_ng0n1`
+
 ## Virtio Block {#bdev_config_virtio_blk}
 
 The Virtio-Block driver allows creating SPDK bdevs from Virtio-Block devices.
@@ -601,3 +656,30 @@ Virtio-SCSI devices can be removed with the following command
 `rpc.py bdev_virtio_detach_controller VirtioScsi0`
 
 Removing a Virtio-SCSI device will destroy all its bdevs.
+
+## DAOS bdev {#bdev_config_daos}
+
+DAOS bdev creates SPDK block device on top of DAOS DFS, the name of the bdev defines the file name in DFS namespace.
+Note that DAOS container has to be POSIX type, e.g.: ` daos cont create --pool=test-pool --label=test-cont --type=POSIX`
+
+To build SPDK with daos support, daos-devel package has to be installed, please see the setup [guide](https://docs.daos.io/v2.0/).
+To enable the module, configure SPDK using `--with-daos` flag.
+
+Running `daos_agent` service on the target machine is required for the SPDK DAOS bdev communication with a DAOS cluster.
+
+The implementation uses the independent pool and container connections per device's channel for the best IO throughput, therefore,
+running a target application with multiple cores (`-m [0-7], for example) is highly advisable.
+
+Example command for creating daos bdev:
+
+`rpc.py bdev_daos_create daosdev0 test-pool test-cont 64 4096`
+
+Example command for removing daos bdev:
+
+`rpc.py bdev_daos_delete daosdev0`
+
+To resize a bdev use the bdev_daos_resize command.
+
+`rpc.py bdev_daos_resize daosdev0 8192`
+
+This command will resize the daosdev0 bdev to 8192 MiB.

doc/bdev_module.md

@@ -151,13 +151,46 @@ bdev module. Refer to test/external_code/README.md and @ref so_linking for furth
 Block devices are considered virtual if they handle I/O requests by routing
 the I/O to other block devices. The canonical example would be a bdev module
 that implements RAID. Virtual bdevs are created in the same way as regular
-bdevs, but take one additional step. The module can look up the underlying
+bdevs, but take the one additional step of claiming the bdev.
-bdevs it wishes to route I/O to using spdk_bdev_get_by_name(), where the string
+
-name is provided by the user via an RPC. The module
+The module can open the underlying bdevs it wishes to route I/O to using
-then may proceed is normal by opening the bdev to obtain a descriptor, and
+spdk_bdev_open_ext(), where the string name is provided by the user via an RPC.
-creating I/O channels for the bdev (probably in response to the
+To ensure that other consumers do not modify the underlying bdev in an unexpected
-`get_io_channel` callback). The final step is to have the module use its open
+way, the virtual bdev should take a claim on the underlying bdev before
-descriptor to call spdk_bdev_module_claim_bdev(), indicating that it is
+reading from or writing to the underlying bdev.
-consuming the underlying bdev. This prevents other users from opening
+
-descriptors with write permissions. This effectively 'promotes' the descriptor
+There are two slightly different APIs for taking and releasing claims. The
-to write-exclusive and is an operation only available to bdev modules.
+preferred interface uses `spdk_bdev_module_claim_bdev_desc()`. This method allows
+claims that ensure there is a single writer with
+`SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE`, cooperating shared writers with
+`SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED`, and shared readers that prevent any
+writers with `SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE`. In all cases,
+`spdk_bdev_open_ext()` may be used to open the underlying bdev read-only. If a
+read-only bdev descriptor successfully claims a bdev with
+`SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE` or `SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED`
+the bdev descriptor is promoted to read-write.
+Any claim that is obtained with `spdk_bdev_module_claim_bdev_desc()` is
+automatically released upon closing the bdev descriptor used to obtain the
+claim. Shared claims continue to block new incompatible claims and new writers
+until the last claim is released.
+
+The non-preferred interface for obtaining a claim allows the caller to obtain
+an exclusive writer claim with `spdk_bdev_module_claim_bdev()`. It may be
+be released with `spdk_bdev_module_release_bdev()`. If a read-only bdev
+descriptor is passed, it is promoted to read-write.  NULL may be passed instead
+of a bdev descriptor to avoid promotion and to block new writers. New code
+should use `spdk_bdev_module_claim_bdev_desc()` with the claim type that is
+tailored to the virtual bdev's needs.
+
+The descriptor obtained from the successful spdk_bdev_open_ext() may be used
+with spdk_bdev_get_io_channel() to obtain I/O channels for the bdev. This is
+likely done in response to the virtual bdev's `get_io_channel` callback.
+Channels may be obtained before and/or after claiming the underlying bdev, but
+beware there may be other unknown writers until the underlying bdev has been
+claimed.
+
+When a virtual bdev module claims an underlying bdev from its `examine_config`
+callback, it causes the `examine_disk` callback to only be called for this
+module and any others that establish a shared claim. If no claims are taken by
+`examine_config` callbacks, all virtual bdevs' `examine_disk` callbacks are
+called.

doc/bdev_pg.md

@@ -63,7 +63,7 @@ to tear down the bdev library, call spdk_bdev_finish().
 All block devices have a simple string name. At any time, a pointer to the
 device object can be obtained by calling spdk_bdev_get_by_name(), or the entire
 set of bdevs may be iterated using spdk_bdev_first() and spdk_bdev_next() and
-their variants.
+their variants or spdk_for_each_bdev() and its variant.
 
 Some block devices may also be given aliases, which are also string names.
 Aliases behave like symlinks - they can be used interchangeably with the real

doc/bdevperf.md

@@ -1,23 +1,23 @@
-# Using bdevperf application {#bdevperf}
+# bdevperf {#bdevperf}
 
 ## Introduction
 
-bdevperf is an SPDK application that is used for performance testing
+bdevperf is an SPDK application used for performance testing
 of block devices (bdevs) exposed by the SPDK bdev layer.  It is an
 alternative to the SPDK bdev fio plugin for benchmarking SPDK bdevs.
-In some cases, bdevperf can provide much lower overhead than the fio
+In some cases, bdevperf can provide lower overhead than the fio
-plugin, resulting in much better performance for tests using a limited
+plugin, resulting in better performance and efficiency for tests
-number of CPU cores.
+using a limited number of CPU cores.
 
 bdevperf exposes command line interface that allows to specify
 SPDK framework options as well as testing options.
-Since SPDK 20.07, bdevperf supports configuration file that is similar
+bdevperf also supports a configuration file format similar
 to FIO. It allows user to create jobs parameterized by
 filename, cpumask, blocksize, queuesize, etc.
 
 ## Config file
 
-Bdevperf's config file is similar to FIO's config file format.
+bdevperf's config file format is similar to FIO.
 
 Below is an example config file that uses all available parameters:
 

doc/blob.md

@@ -57,56 +57,17 @@ The Blobstore defines a hierarchy of storage abstractions as follows.
   Blobstore owns the entire underlying device which is made up of a private Blobstore metadata region and the collection of
   blobs as managed by the application.
 
-@htmlonly
+```text
-
++-----------------------------------------------------------------+
-  <div id="blob_hierarchy"></div>
+|                              Blob                               |
-
+| +-----------------------------+ +-----------------------------+ |
-  <script>
+| |           Cluster           | |           Cluster           | |
-    let elem = document.getElementById('blob_hierarchy');
+| | +----+ +----+ +----+ +----+ | | +----+ +----+ +----+ +----+ | |
-
+| | |Page| |Page| |Page| |Page| | | |Page| |Page| |Page| |Page| | |
-    let canvasWidth = 800;
+| | +----+ +----+ +----+ +----+ | | +----+ +----+ +----+ +----+ | |
-    let canvasHeight = 200;
+| +-----------------------------+ +-----------------------------+ |
-    var two = new Two({ width: 800, height: 200 }).appendTo(elem);
++-----------------------------------------------------------------+
-
+```
-    var blobRect = two.makeRectangle(canvasWidth / 2, canvasHeight / 2, canvasWidth, canvasWidth);
-    blobRect.fill = '#7ED3F7';
-
-    var blobText = two.makeText('Blob', canvasWidth / 2, 10, { alignment: 'center'});
-
-    for (var i = 0; i < 2; i++) {
-        let clusterWidth = 400;
-        let clusterHeight = canvasHeight;
-        var clusterRect = two.makeRectangle((clusterWidth / 2) + (i * clusterWidth),
-                                            clusterHeight / 2,
-                                            clusterWidth - 10,
-                                            clusterHeight - 50);
-        clusterRect.fill = '#00AEEF';
-
-        var clusterText =  two.makeText('Cluster',
-                                        (clusterWidth / 2) + (i * clusterWidth),
-                                        35,
-                                        { alignment: 'center', fill: 'white' });
-
-        for (var j = 0; j < 4; j++) {
-            let pageWidth = 100;
-            let pageHeight = canvasHeight;
-            var pageRect = two.makeRectangle((pageWidth / 2) + (j * pageWidth) + (i * clusterWidth),
-                                             pageHeight / 2,
-                                             pageWidth - 20,
-                                             pageHeight - 100);
-            pageRect.fill = '#003C71';
-
-            var pageText =  two.makeText('Page',
-                                         (pageWidth / 2) + (j * pageWidth) + (i * clusterWidth),
-                                         pageHeight / 2,
-                                         { alignment: 'center', fill: 'white' });
-        }
-    }
-
-    two.update();
-  </script>
-
-@endhtmlonly
 
 ### Atomicity
 
@@ -168,6 +129,11 @@ Channels are an SPDK-wide abstraction and with Blobstore the best way to think a
 required in order to do IO.  The application will perform IO to the channel and channels are best thought of as being
 associated 1:1 with a thread.
 
+With external snapshots (see @ref blob_pg_esnap_and_esnap_clone), a read from a blob may lead to
+reading from the device containing the blobstore or an external snapshot device. To support this,
+each blobstore IO channel maintains a tree of channels to be used when reading from external
+snapshot devices.
+
 ### Blob Identifiers
 
 When an application creates a blob, it does not provide a name as is the case with many other similar
@@ -198,6 +164,9 @@ options and their defaults are:
   Blobstore found here is appropriate to claim or not. The default is NULL and unless the application is being deployed in
   an environment where multiple applications using the same disks are at risk of inadvertently using the wrong Blobstore, there
   is no need to set this value. It can, however, be set to any valid set of characters.
+* **External Snapshot Device Creation Callback**: If the blobstore supports external snapshots this function will be called
+  as a blob that clones an external snapshot (an "esnap clone") is opened so that the blobstore consumer can load the external
+  snapshot and register a blobstore device that will satisfy read requests. See @ref blob_pg_esnap_and_esnap_clone.
 
 ### Sub-page Sized Operations
 
@@ -341,6 +310,152 @@ when creating a blob.
   Extents pointing to contiguous LBA are run-length encoded, including unallocated extents represented by 0.
   Every new cluster allocation incurs serializing whole linked list of pages for the blob.
 
+### Thin Blobs, Snapshots, and Clones
+
+Each in-use cluster is allocated to blobstore metadata or to a particular blob. Once a cluster is
+allocated to a blob it is considered owned by that blob and that particular blob's metadata
+maintains a reference to the cluster as a record of ownership. Cluster ownership is transferred
+during snapshot operations described later in @ref blob_pg_snapshots.
+
+Through the use of thin provisioning, snapshots, and/or clones, a blob may be backed by clusters it
+owns, clusters owned by another blob, or by a zeroes device. The behavior of reads and writes depend
+on whether the operation targets blocks that are backed by a cluster owned by the blob or not.
+
+* **read from blocks on an owned cluster**: The read is serviced by reading directly from the
+  appropriate cluster.
+* **read from other blocks**: The read is passed on to the blob's *back device* and the back
+  device services the read. The back device may be another blob or it may be a zeroes device.
+* **write to blocks on an owned cluster**: The write is serviced by writing directly to the
+  appropriate cluster.
+* **write to thin provisioned cluster**: If the back device is the zeroes device and no cluster
+  is allocated to the blob the process described in @ref blob_pg_thin_provisioning is followed.
+* **write to other blocks**: A copy-on-write operation is triggered. See @ref blob_pg_copy_on_write
+  for details.
+
+External snapshots allow some external data source to act as a snapshot. This allows clones to be
+created of data that resides outside of the blobstore containing the clone.
+
+#### Thin Provisioning {#blob_pg_thin_provisioning}
+
+As mentioned in @ref blob_pg_cluster_layout, a blob may be thin provisioned. A thin provisioned blob
+starts out with no allocated clusters. Clusters are allocated as writes occur. A thin provisioned
+blob's back device is a *zeroes device*. A read from a zeroes device fills the read buffer with
+zeroes.
+
+When a thin provisioned volume writes to a block that does not have an allocated cluster, the
+following steps are performed:
+
+1. Allocate a cluster.
+2. Update blob metadata.
+3. Perform the write.
+
+#### Snapshots and Clones {#blob_pg_snapshots}
+
+A snapshot is a read-only blob that may have clones. A snapshot may itself be a clone of one other
+blob. While the interface gives the illusion of being able to create many snapshots of a blob, under
+the covers this results in a chain of snapshots that are clones of the previous snapshot.
+
+When blob1 is snapshotted, a new read-only blob is created and blob1 becomes a clone of this new
+blob. That is:
+
+| Step | Action                         | State                                             |
+| ---- | ------------------------------ | ------------------------------------------------- |
+| 1    | Create blob1                   | `blob1 (rw)`                                      |
+| 2    | Create snapshot blob2 of blob1 | `blob1 (rw) --> blob2 (ro)`                       |
+| 2a   | Write to blob1                 | `blob1 (rw) --> blob2 (ro)`                       |
+| 3    | Create snapshot blob3 of blob1 | `blob1 (rw) --> blob3 (ro) ---> blob2 (ro)`       |
+
+Supposing blob1 was not thin provisioned, step 1 would have allocated clusters needed to perform a
+full write of blob1. As blob2 is created in step 2, the ownership of all of blob1's clusters is
+transferred to blob2 and blob2 becomes blob1's back device. During step2a, the writes to blob1 cause
+one or more clusters to be allocated to blob1. When blob3 is created in step 3, the clusters
+allocated in step 2a are given to blob3, blob3's back device becomes blob2, and blob1's back device
+becomes blob3.
+
+It is important to understand the chain above when considering strategies to use a golden image from
+which many clones are made. The IO path is more efficient if one snapshot is cloned many times than
+it is to create a new snapshot for every clone. The following illustrates the difference.
+
+Using a single snapshot means the data originally referenced by the golden image is always one hop
+away.
+
+```text
+create golden                           golden --> golden-snap
+snapshot golden as golden-snap                     ^ ^ ^
+clone golden-snap as clone1              clone1 ---+ | |
+clone golden-snap as clone2              clone2 -----+ |
+clone golden-snap as clone3              clone3 -------+
+```
+
+Using a snapshot per clone means that the chain of back devices grows with every new snapshot and
+clone pair. Reading a block from clone3 may result in a read from clone3's back device (snap3), from
+clone2's back device (snap2), then finally clone1's back device (snap1, the current owner of the
+blocks originally allocated to golden).
+
+```text
+create golden
+snapshot golden as snap1                golden --> snap3 -----> snap2 ----> snap1
+clone snap1 as clone1                   clone3----/   clone2 --/  clone1 --/
+snapshot golden as snap2
+clone snap2 as clone2
+snapshot golden as snap3
+clone snap3 as clone3
+```
+
+A snapshot with no more than one clone can be deleted. When a snapshot with one clone is deleted,
+the clone becomes a regular blob. The clusters owned by the snapshot are transferred to the clone or
+freed, depending on whether the clone already owns a cluster for a particular block range.
+
+Removal of the last clone leaves the snapshot in place. This snapshot continues to be read-only and
+can serve as the snapshot for future clones.
+
+#### Inflating and Decoupling Clones
+
+A clone can remove its dependence on a snapshot with the following operations:
+
+1. Inflate the clone. Clusters backed by any snapshot or a zeroes device are copied into newly
+   allocated clusters. The blob becomes a thick provisioned blob.
+2. Decouple the clone. Clusters backed by the first back device snapshot are copied into newly
+   allocated clusters. If the clone's back device snapshot was itself a clone of another
+   snapshot, the clone remains a clone but is now a clone of a different snapshot.
+3. Remove the snapshot. This is only possible if the snapshot has one clone. The end result is
+   usually the same as decoupling but ownership of clusters is transferred from the snapshot rather
+   than being copied. If the snapshot that was deleted was itself a clone of another snapshot, the
+   clone remains a clone, but is now a clone of a different snapshot.
+
+#### External Snapshots and Esnap Clones {#blob_pg_esnap_and_esnap_clone}
+
+A blobstore that is loaded with the `esnap_bs_dev_create` callback defined will support external
+snapshots (esnaps). An external snapshot is not useful on its own: it needs to be cloned by a blob.
+A clone of an external snapshot is referred to as an *esnap clone*. An esnap clone supports IO and
+other operations just like any other clone.
+
+An esnap clone can be recognized in various ways:
+
+* **On disk**: the blob metadata has the `SPDK_BLOB_EXTERNAL_SNAPSHOT` (0x8) bit is set in
+  `invalid_flags` and an internal XATTR with name `BLOB_EXTERNAL_SNAPSHOT_ID` ("EXTSNAP") exists.
+* **In memory**: The `spdk_blob` structure contains the metadata read from disk, `blob->parent_id`
+  is set to `SPDK_BLOBID_EXTERNAL_SNAPSHOT`, and `blob->back_bs_dev` references a blobstore device
+  which is not a blob in the same blobstore nor a zeroes device.
+
+#### Copy-on-write {#blob_pg_copy_on_write}
+
+A copy-on-write operation is somewhat expensive, with the cost being proportional to the cluster
+size. Typical copy-on-write involves the following steps:
+
+1. Allocate a cluster.
+2. Allocate a cluster-sized buffer into which data can be read.
+3. Trigger a full-cluster read from the back device into the cluster-sized buffer.
+4. Write from the cluster-sized buffer into the newly allocated cluster.
+5. Update the blob's on-disk metadata to record ownership of the newly allocated cluster. This
+   involves at least one page-sized write.
+6. Write the new data to the just allocated and copied cluster.
+
+If the source cluster is backed by a zeroes device, steps 2 through 4 are skipped. Alternatively, if
+the blobstore resides on a device that can perform the copy on its own, steps 2 through 4 are
+offloaded to the device. Neither of these optimizations are available when the back device is an
+external snapshot.
+
 ### Sequences and Batches
 
 Internally Blobstore uses the concepts of sequences and batches to submit IO to the underlying device in either
@@ -355,6 +470,13 @@ of IO. They are an internal construct only and are pre-allocated on a per channe
 earlier). They are removed from a channel associated linked list when the set (sequence or batch) is started and
 then returned to the list when completed.
 
+Each request set maintains a reference to a `channel` and a `back_channel`. The `channel` is used
+for performing IO on the blobstore device. The `back_channel` is used for performing IO on the
+blob's back device, `blob->back_bs_dev`. For blobs that are not esnap clones, `channel` and
+`back_channel` reference an IO channel used with the device that contains the blobstore.  For blobs
+that are esnap clones, `channel` is the same as with any other blob and `back_channel` is an IO
+channel for the external snapshot device.
+
 ### Key Internal Structures
 
 `blobstore.h` contains many of the key structures for the internal workings of Blobstore. Only a few notable ones

doc/concurrency.md

@@ -110,6 +110,18 @@ repeatedly call `spdk_thread_poll()` on each `spdk_thread()` that exists. This
 makes SPDK very portable to a wide variety of asynchronous, event-based
 frameworks such as [Seastar](https://www.seastar.io) or [libuv](https://libuv.org/).
 
+## SPDK Spinlocks
+
+There are some cases where locks are used. These should be limited in favor of
+the message passing interface described above. When locks are needed,
+SPDK spinlocks should be used instead of POSIX locks.
+
+POSIX locks like `pthread_mutex_t` and `pthread_spinlock_t` do not properly
+handle locking between SPDK's lightweight threads. SPDK's `spdk_spinlock`
+is safe to use in SPDK libraries and applications. This safety comes from
+imposing restrictions on when locks can be held. See
+[spdk_spinlock](structspdk__spinlock.html) for details.
+
 ## The event Framework
 
 The SPDK project didn't want to officially pick an asynchronous, event-based

doc/containers.md

@@ -6,22 +6,9 @@ here.
 
 ## In this document {#containers_toc}
 
-* @ref kata_containers_with_spdk_vhost
 * @ref spdk_in_docker
-
+* @ref spdk_docker_suite
-## Using SPDK vhost target to provide volume service to Kata Containers and Docker {#kata_containers_with_spdk_vhost}
+* @ref kata_containers_with_spdk_vhost
-
-[Kata Containers](https://katacontainers.io) can build a secure container
-runtime with lightweight virtual machines that feel and perform like
-containers, but provide stronger workload isolation using hardware
-virtualization technology as a second layer of defense.
-
-From Kata Containers [1.11.0](https://github.com/kata-containers/runtime/releases/tag/1.11.0),
-vhost-user-blk support is enabled in `kata-containers/runtime`. That is to say
-SPDK vhost target can be used to provide volume service to Kata Containers directly.
-In addition, a container manager like Docker, can be configured easily to launch
-a Kata container with an SPDK vhost-user block device. For operating details, visit
-Kata containers use-case [Setup to run SPDK vhost-user devices with Kata Containers and Docker](https://github.com/kata-containers/documentation/blob/master/use-cases/using-SPDK-vhostuser-and-kata.md#host-setup-for-vhost-user-devices)
 
 ## Containerizing an SPDK Application for Docker {#spdk_in_docker}
 
@@ -90,3 +77,25 @@ Initialization complete.
 INFO: using host memory buffer for IO
 Hello world!
 ~~~
+
+## SPDK Docker suite {#spdk_docker_suite}
+
+When considering how to generate SPDK docker container images formally,
+deploy SPDK containers correctly, interact with SPDK container instances,
+and orchestrate SPDK container instances, you can get practiced and inspired from
+this SPDK docker-compose example:
+[SPDK Docker suite](https://github.com/spdk/spdk/blob/master/docker/README.md).
+
+## Using SPDK vhost target to provide volume service to Kata Containers and Docker {#kata_containers_with_spdk_vhost}
+
+[Kata Containers](https://katacontainers.io) can build a secure container
+runtime with lightweight virtual machines that feel and perform like
+containers, but provide stronger workload isolation using hardware
+virtualization technology as a second layer of defense.
+
+From Kata Containers [1.11.0](https://github.com/kata-containers/runtime/releases/tag/1.11.0),
+vhost-user-blk support is enabled in `kata-containers/runtime`. That is to say
+SPDK vhost target can be used to provide volume service to Kata Containers directly.
+In addition, a container manager like Docker, can be configured easily to launch
+a Kata container with an SPDK vhost-user block device. For operating details, visit
+Kata containers use-case [Setup to run SPDK vhost-user devices with Kata Containers and Docker](https://github.com/kata-containers/documentation/blob/master/use-cases/using-SPDK-vhostuser-and-kata.md#host-setup-for-vhost-user-devices)

doc/distributions.md

@@ -15,8 +15,7 @@ jobs (see [status](https://ci.spdk.io) as a reference).
 
 ## Linux distributions {#linux_list}
 
-* Fedora: Trying to follow new release as per the release cycle whenever
+* Fedora: Trying to follow new release as per the release cycle whenever possible.
-          possible. Currently at `Fedora33`.
 
 ```list
 - autobuild-vg-autotest
@@ -41,20 +40,26 @@ Fedora may vary. In the future these will be aligned with the
 - vhost-autotest
 ```
 
-* Ubuntu: Last two LTS releases. Currently `20.04` and `18.04`.
+* Ubuntu: Last two LTS releases. Currently `18.04` and `20.04`.
 
 ```list
 - ubuntu18-vg-autotest
 - ubuntu20-vg-autotest
 ```
 
-* CentOS: Maintained releases. Currently `7.9` and `8.2`.
+* CentOS: Maintained releases. Currently `7.9`. Centos 8.3 is only used for testing on 22.01.x branch.
 
 ```list
 - centos7-vg-autotest
 - centos8-vg-autotest
 ```
 
+* Rocky Linux: Last release. Currently `8.6`. CentOS 8 replacement.
+
+```list
+- rocky8-vg-autotest
+```
+
 ## FreeBSD distributions {#freebsd_list}
 
 * FreeBSD: Production release. Currently `12.2`.

doc/ftl.md

@@ -1,21 +1,26 @@
 # Flash Translation Layer {#ftl}
 
-The Flash Translation Layer library provides block device access on top of devices
+The Flash Translation Layer library provides efficient 4K block device access on top of devices
-implementing bdev_zone interface.
+with >4K write unit size (eg. raid5f bdev) or devices with large indirection units (some
-It handles the logical to physical address mapping, responds to the asynchronous
+capacity-focused NAND drives), which don't handle 4K writes well. It handles the logical to
-media management events, and manages the defragmentation process.
+physical address mapping and manages the garbage collection process.
 
 ## Terminology {#ftl_terminology}
 
-### Logical to physical address map
+### Logical to physical address map {#ftl_l2p}
 
-- Shorthand: L2P
+- Shorthand: `L2P`
 
 Contains the mapping of the logical addresses (LBA) to their on-disk physical location. The LBAs
 are contiguous and in range from 0 to the number of surfaced blocks (the number of spare blocks
 are calculated during device formation and are subtracted from the available address space). The
 spare blocks account for zones going offline throughout the lifespan of the device as well as
-provide necessary buffer for data [defragmentation](#ftl_reloc).
+provide necessary buffer for data [garbage collection](#ftl_reloc).
+
+Since the L2P would occupy a significant amount of DRAM (4B/LBA for drives smaller than 16TiB,
+8B/LBA for bigger drives), FTL will, by default, store only the 2GiB of most recently used L2P
+addresses in memory (the amount is configurable), and page them in and out of the cache device
+as necessary.
 
 ### Band {#ftl_band}
 
@@ -45,71 +50,55 @@ from the oldest band to the youngest.
               parallel unit 1              pu 2                                    pu n
 ```
 
-The address map and valid map are, along with a several other things (e.g. UUID of the device it's
+The address map (`P2L`) is saved as a part of the band's metadata, at the end of each band:
-part of, number of surfaced LBAs, band's sequence number, etc.), parts of the band's metadata. The
-metadata is split in two parts:
 
 ```text
-       head metadata               band's data               tail metadata
+                        band's data                        tail metadata
     +-------------------+-------------------------------+------------------------+
     |zone 1 |...|zone n |...|...|zone 1 |...|           | ... |zone  m-1 |zone  m|
     |block 1|   |block 1|   |   |block x|   |           |     |block y   |block y|
     +-------------------+-------------+-----------------+------------------------+
 ```
 
-- the head part, containing information already known when opening the band (device's UUID, band's
-  sequence number, etc.), located at the beginning blocks of the band,
-- the tail part, containing the address map and the valid map, located at the end of the band.
-
 Bands are written sequentially (in a way that was described earlier). Before a band can be written
 to, all of its zones need to be erased. During that time, the band is considered to be in a `PREP`
-state. After that is done, the band transitions to the `OPENING` state, in which head metadata
+state. Then the band moves to the `OPEN` state and actual user data can be written to the
-is being written. Then the band moves to the `OPEN` state and actual user data can be written to the
 band. Once the whole available space is filled, tail metadata is written and the band transitions to
 `CLOSING` state. When that finishes the band becomes `CLOSED`.
 
-### Ring write buffer {#ftl_rwb}
+### Non volatile cache {#ftl_nvcache}
 
-- Shorthand: RWB
+- Shorthand: `nvcache`
-
-Because the smallest write size the SSD may support can be a multiple of block size, in order to
-support writes to a single block, the data needs to be buffered. The write buffer is the solution to
-this problem. It consists of a number of pre-allocated buffers called batches, each of size allowing
-for a single transfer to the SSD. A single batch is divided into block-sized buffer entries.
 
+Nvcache is a bdev that is used for buffering user writes and storing various metadata.
+Nvcache data space is divided into chunks. Chunks are written in sequential manner.
+When number of free chunks is below assigned threshold data from fully written chunks
+is moved to base_bdev. This process is called chunk compaction.
 ```text
-                 write buffer
+                      nvcache
-    +-----------------------------------+
+    +-----------------------------------------+
-    |batch 1                            |
+    |chunk 1                                  |
-    |   +-----------------------------+ |
+    |   +--------------------------------- +  |
-    |   |rwb    |rwb    | ... |rwb    | |
+    |   |blk 1 + md| blk 2 + md| blk n + md|  |
-    |   |entry 1|entry 2|     |entry n| |
+    |   +----------------------------------|  |
-    |   +-----------------------------+ |
+    +-----------------------------------------+
-    +-----------------------------------+
+    | ...                                     |
-    | ...                               |
+    +-----------------------------------------+
-    +-----------------------------------+
+    +-----------------------------------------+
-    |batch m                            |
+    |chunk N                                  |
-    |   +-----------------------------+ |
+    |   +--------------------------------- +  |
-    |   |rwb    |rwb    | ... |rwb    | |
+    |   |blk 1 + md| blk 2 + md| blk n + md|  |
-    |   |entry 1|entry 2|     |entry n| |
+    |   +----------------------------------|  |
-    |   +-----------------------------+ |
+    +-----------------------------------------+
-    +-----------------------------------+
 ```
 
-When a write is scheduled, it needs to acquire an entry for each of its blocks and copy the data
+### Garbage collection and relocation {#ftl_reloc}
-onto this buffer. Once all blocks are copied, the write can be signalled as completed to the user.
-In the meantime, the `rwb` is polled for filled batches and, if one is found, it's sent to the SSD.
-After that operation is completed the whole batch can be freed. For the whole time the data is in
-the `rwb`, the L2P points at the buffer entry instead of a location on the SSD. This allows for
-servicing read requests from the buffer.
 
-### Defragmentation and relocation {#ftl_reloc}
+- Shorthand: gc, reloc
-
-- Shorthand: defrag, reloc
 
 Since a write to the same LBA invalidates its previous physical location, some of the blocks on a
 band might contain old data that basically wastes space. As there is no way to overwrite an already
-written block, this data will stay there until the whole zone is reset. This might create a
+written block for a ZNS drive, this data will stay there until the whole zone is reset. This might create a
 situation in which all of the bands contain some valid data and no band can be erased, so no writes
 can be executed anymore. Therefore a mechanism is needed to move valid data and invalidate whole
 bands, so that they can be reused.
@@ -125,28 +114,62 @@ bands, so that they can be reused.
 
 Valid blocks are marked with an asterisk '\*'.
 
-Another reason for data relocation might be an event from the SSD telling us that the data might
+Module responsible for data relocation is called `reloc`. When a band is chosen for garbage collection,
-become corrupt if it's not relocated. This might happen due to its old age (if it was written a
+the appropriate blocks are marked as required to be moved. The `reloc` module takes a band that has
-long time ago) or due to read disturb (media characteristic, that causes corruption of neighbouring
+some of such blocks marked, checks their validity and, if they're still valid, copies them.
-blocks during a read operation).
 
-Module responsible for data relocation is called `reloc`. When a band is chosen for defragmentation
+Choosing a band for garbage collection depends its validity ratio (proportion of valid blocks to all
-or a media management event is received, the appropriate blocks are marked as
+user blocks). The lower the ratio, the higher the chance the band will be chosen for gc.
-required to be moved. The `reloc` module takes a band that has some of such blocks marked, checks
-their validity and, if they're still valid, copies them.
 
-Choosing a band for defragmentation depends on several factors: its valid ratio (1) (proportion of
+## Metadata {#ftl_metadata}
-valid blocks to all user blocks), its age (2) (when was it written) and its write count / wear level
+
-index of its zones (3) (how many times the band was written to). The lower the ratio (1), the
+In addition to the [L2P](#ftl_l2p), FTL will store additional metadata both on the cache, as
-higher its age (2) and the lower its write count (3), the higher the chance the band will be chosen
+well as on the base devices. The following types of metadata are persisted:
-for defrag.
+
+- Superblock - stores the global state of FTL; stored on cache, mirrored to the base device
+
+- L2P - see the [L2P](#ftl_l2p) section for details
+
+- Band - stores the state of bands - write pointers, their OPEN/FREE/CLOSE state; stored on cache, mirrored to a different section of the cache device
+
+- Valid map - bitmask of all the valid physical addresses, used for improving [relocation](#ftl_reloc)
+
+- Chunk - stores the state of chunks - write pointers, their OPEN/FREE/CLOSE state; stored on cache, mirrored to a different section of the cache device
+
+- P2L - stores the address mapping (P2L, see [band](#ftl_band)) of currently open bands. This allows for the recovery of open
+ bands after dirty shutdown without needing VSS DIX metadata on the base device; stored on the cache device
+
+- Trim - stores information about unmapped (trimmed) LBAs; stored on cache, mirrored to a different section of the cache device
+
+## Dirty shutdown recovery {#ftl_dirty_shutdown}
+
+After power failure, FTL needs to rebuild the whole L2P using the address maps (`P2L`) stored within each band/chunk.
+This needs to done, because while individual L2P pages may have been paged out and persisted to the cache device,
+there's no way to tell which, if any, pages were dirty before the power failure occurred. The P2L consists of not only
+the mapping itself, but also a sequence id (`seq_id`), which describes the relative age of a given logical block
+(multiple writes to the same logical block would produce the same amount of P2L entries, only the last one having the current data).
+
+FTL will therefore rebuild the whole L2P by reading the P2L of all closed bands and chunks. For open bands, the P2L is stored on
+the cache device, in a separate metadata region (see [the P2L section](#ftl_metadata)). Open chunks can be restored thanks to storing
+the mapping in the VSS DIX metadata, which the cache device must be formatted with.
+
+### Shared memory recovery {#ftl_shm_recovery}
+
+In order to shorten the recovery after crash of the target application, FTL also stores its metadata in shared memory (`shm`) - this
+allows it to keep track of the dirty-ness state of individual pages and shortens the recovery time dramatically, as FTL will only
+need to mark any potential L2P pages which were paging out at the time of the crash as dirty and reissue the writes. There's no need
+to read the whole P2L in this case.
+
+### Trim {#ftl_trim}
+
+Due to metadata size constraints and the difficulty of maintaining consistent data returned before and after dirty shutdown, FTL
+currently only allows for trims (unmaps) aligned to 4MiB (alignment concerns both the offset and length of the trim command).
 
 ## Usage {#ftl_usage}
 
 ### Prerequisites {#ftl_prereq}
 
-In order to use the FTL module, a device capable of zoned interface is required e.g. `zone_block`
+In order to use the FTL module, a cache device formatted with VSS DIX metadata is required.
-bdev or OCSSD `nvme` bdev.
 
 ### FTL bdev creation {#ftl_create}
 
@@ -155,51 +178,27 @@ Both interfaces require the same arguments which are described by the `--help` o
 `bdev_ftl_create` RPC call, which are:
 
 - bdev's name
-- base bdev's name (base bdev must implement bdev_zone API)
+- base bdev's name
+- cache bdev's name (cache bdev must support VSS DIX mode - could be emulated by providing SPDK_FTL_VSS_EMU=1 flag to make;
+ emulating VSS should be done for testing purposes only, it is not power-fail safe)
 - UUID of the FTL device (if the FTL is to be restored from the SSD)
 
-## Configuring SPDK {#ftl_spdk_config}
+## FTL bdev stack {#ftl_bdev_stack}
-
-To verify that the drive is emulated correctly, one can check the output of the NVMe identify app
-(assuming that `scripts/setup.sh` was called before and the driver has been changed for that
-device):
-
-```bash
-$ build/examples/identify
-=====================================================
-NVMe Controller at 0000:00:0a.0 [1d1d:1f1f]
-=====================================================
-Controller Capabilities/Features
-================================
-Vendor ID:                             1d1d
-Subsystem Vendor ID:                   1af4
-Serial Number:                         deadbeef
-Model Number:                          QEMU NVMe Ctrl
-
-... other info ...
-
-```
-
-## FTL usage with zone block bdev {#ftl_zone_block}
-
-Zone block bdev is a bdev adapter between regular `bdev` and `bdev_zone`. It emulates a zoned
-interface on top of a regular block device.
 
 In order to create FTL on top of a regular bdev:
 1) Create regular bdev e.g. `bdev_nvme`, `bdev_null`, `bdev_malloc`
-2) Create zone block bdev on top of a regular bdev created in step 1 (user could specify zone capacity
+2) Create second regular bdev for nvcache
-and optimal number of open zones)
+3) Create FTL bdev on top of bdev created in step 1 and step 2
-3) Create FTL bdev on top of bdev created in step 2
 
 Example:
 ```
 $ scripts/rpc.py bdev_nvme_attach_controller -b nvme0 -a 00:05.0 -t pcie
 	nvme0n1
 
-$ scripts/rpc.py bdev_zone_block_create -b zone1 -n nvme0n1 -z 4096 -o 32
+$ scripts/rpc.py bdev_nvme_attach_controller -b nvme1 -a 00:06.0 -t pcie
-	zone1
+	nvme1n1
 
-$ scripts/rpc.py bdev_ftl_create -b ftl0 -d zone1
+$ scripts/rpc.py bdev_ftl_create -b ftl0 -d nvme0n1 -c nvme1n1
 {
 	"name": "ftl0",
 	"uuid": "3b469565-1fa5-4bfb-8341-747ec9f3a9b9"

doc/gdb_macros.md

@@ -125,6 +125,54 @@ nqn "nqn.2016-06.io.spdk.umgmt:cnode1", '\000' <repeats 191 times>
 ID 1
 ~~~
 
+Printing SPDK spinlocks:
+
+In this example, the spinlock has been initialized and locked but has never been unlocked.
+After it is unlocked the first time the last unlocked stack will be present and the
+`Locked by spdk_thread` line will say `not locked`.
+
+~~~{.sh}
+Breakpoint 2, spdk_spin_unlock (sspin=0x655110 <g_bdev_mgr+80>) at thread.c:2915
+2915            struct spdk_thread *thread = spdk_get_thread();
+(gdb) print *sspin
+$2 = struct spdk_spinlock:
+  Locked by spdk_thread: 0x658080
+  Initialized at:
+     0x43e677 <spdk_spin_init+213> thread.c:2878
+     0x404feb <_bdev_init+16> /build/spdk/spdk-review-public/lib/bdev/bdev.c:116
+     0x44483d <__libc_csu_init+77>
+     0x7ffff62c9d18 <__libc_start_main+120>
+     0x40268e <_start+46>
+  Last locked at:
+     0x43e936 <spdk_spin_lock+436> thread.c:2909
+     0x40ca9c <bdev_name_add+129> /build/spdk/spdk-review-public/lib/bdev/bdev.c:3855
+     0x411a3c <bdev_register+641> /build/spdk/spdk-review-public/lib/bdev/bdev.c:6660
+     0x412e1e <spdk_bdev_register+24> /build/spdk/spdk-review-public/lib/bdev/bdev.c:7171
+     0x417895 <num_blocks_test+119> bdev_ut.c:878
+     0x7ffff7bc38cb <run_single_test.constprop+379>
+     0x7ffff7bc3b61 <run_single_suite.constprop+433>
+     0x7ffff7bc3f76 <CU_run_all_tests+118>
+     0x43351f <main+1439> bdev_ut.c:6295
+     0x7ffff62c9d85 <__libc_start_main+229>
+     0x40268e <_start+46>
+  Last unlocked at:
+~~~
+
+Print a single spinlock stack:
+
+~~~{.sh}
+(gdb) print sspin->internal.lock_stack
+$1 = struct sspin_stack:
+ 0x40c6a1 <spdk_spin_lock+436> /build/spdk/spdk-review-public/lib/thread/thread.c:2909
+ 0x413f48 <spdk_spin+552> thread_ut.c:1831
+ 0x7ffff7bc38cb <run_single_test.constprop+379>
+ 0x7ffff7bc3b61 <run_single_suite.constprop+433>
+ 0x7ffff7bc3f76 <CU_run_all_tests+118>
+ 0x4148fa <main+547> thread_ut.c:1948
+ 0x7ffff62c9d85 <__libc_start_main+229>
+ 0x40248e <_start+46>
+~~~
+
 ## Loading The gdb Macros
 
 Copy the gdb macros to the host where you are about to debug.
@@ -175,7 +223,7 @@ iterate the spdk lists and build iterable representations of the list objects.
 This will result in errors if these are not available which is very possible if
 gdb is used for reasons other than debugging spdk core dumps.
 
-In the example bellow, I attempted to load the macros when the globals are not
+In the example below, I attempted to load the macros when the globals are not
 available causing gdb to fail loading the gdb_macros:
 
 ~~~{.sh}

doc/getting_started.md

@@ -3,9 +3,7 @@
 ## Getting the Source Code {#getting_started_source}
 
 ~~~{.sh}
-git clone https://github.com/spdk/spdk
+git clone https://github.com/spdk/spdk --recursive
-cd spdk
-git submodule update --init
 ~~~
 
 ## Installing Prerequisites {#getting_started_prerequisites}

doc/idxd.md

@@ -15,10 +15,9 @@ spdk_idxd_submit_crc32c()               | @copybrief spdk_idxd_submit_crc32c()
 spdk_idxd_submit_dualcast               | @copybrief spdk_idxd_submit_dualcast()
 spdk_idxd_submit_fill()                 | @copybrief spdk_idxd_submit_fill()
 
-## Pre-defined configurations {#idxd_configs}
+## Kernel vs User {#idxd_configs}
 
-The RPC `idxd_scan_accel_engine` is used to both enable IDXD and set it's
+The low level library can be initialized either directly via `spdk_idxd_set_config`,
-configuration to one of two pre-defined configs:
+passing in a value of `true` indicates that the IDXD kernel driver is loaded and
-
+that SPDK will use work queue(s) surfaced by the driver.  Passing in `false` means
-Config #0: 4 groups, 1 work queue per group, 1 engine per group.
+that the SPDK user space driver will be used to initialize the hardware.
-Config #1: 2 groups, 2 work queues per group, 2 engines per group.

doc/img/lvol_esnap_clone.svg

@@ -0,0 +1,673 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   width="181.24mm"
+   height="79.375mm"
+   version="1.1"
+   viewBox="0 0 181.24 79.375"
+   id="svg172"
+   sodipodi:docname="lvol_esnap_clone.svg"
+   inkscape:version="1.2.2 (b0a8486541, 2022-12-01)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:dc="http://purl.org/dc/elements/1.1/">
+  <sodipodi:namedview
+     id="namedview174"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:document-units="mm"
+     showgrid="false"
+     inkscape:zoom="1.7926966"
+     inkscape:cx="338.59607"
+     inkscape:cy="148.93764"
+     inkscape:window-width="1351"
+     inkscape:window-height="930"
+     inkscape:window-x="762"
+     inkscape:window-y="134"
+     inkscape:window-maximized="0"
+     inkscape:current-layer="g170" />
+  <title
+     id="title2">Thin Provisioning</title>
+  <defs
+     id="defs28">
+    <marker
+       id="marker2036"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path4" />
+    </marker>
+    <marker
+       id="marker1960"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path7" />
+    </marker>
+    <marker
+       id="marker1890"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path10" />
+    </marker>
+    <marker
+       id="marker1826"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path13" />
+    </marker>
+    <marker
+       id="marker1816"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path16" />
+    </marker>
+    <marker
+       id="Arrow1Mend"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill-rule="evenodd"
+         stroke="#000"
+         stroke-width="1pt"
+         id="path19" />
+    </marker>
+    <marker
+       id="marker11771-4-9"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill="#f00"
+         fill-rule="evenodd"
+         stroke="#ff2a2a"
+         stroke-width="1pt"
+         id="path22" />
+    </marker>
+    <marker
+       id="marker1826-2-4-7-1-7"
+       overflow="visible"
+       orient="auto">
+      <path
+         transform="matrix(-.4 0 0 -.4 -4 0)"
+         d="m0 0 5-5-17.5 5 17.5 5z"
+         fill="#00f"
+         fill-rule="evenodd"
+         stroke="#00f"
+         stroke-width="1pt"
+         id="path25" />
+    </marker>
+  </defs>
+  <metadata
+     id="metadata30">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title>Thin Provisioning</dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     transform="translate(2.6458 2.3956)"
+     id="g34">
+    <rect
+       x="-2.6458"
+       y="-2.3956"
+       width="181.24"
+       height="79.375"
+       fill="#fffffe"
+       stroke-width=".26458"
+       id="rect32" />
+  </g>
+  <g
+     transform="translate(-3.9688 -4.6356)"
+     id="g170">
+    <g
+       stroke="#000"
+       id="g52">
+      <g
+         stroke-width=".26458"
+         id="g48">
+        <rect
+           x="44.979"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="none"
+           stroke-dasharray="0.52916663, 0.52916663"
+           id="rect36" />
+        <rect
+           x="67.469"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="#d7d7f4"
+           id="rect38" />
+        <rect
+           x="89.958"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="#d7d7f4"
+           id="rect40" />
+        <rect
+           x="112.45"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="none"
+           stroke-dasharray="0.52916663, 0.52916663"
+           id="rect42" />
+        <rect
+           x="134.94"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="none"
+           stroke-dasharray="0.52916663, 0.52916663"
+           id="rect44" />
+        <rect
+           x="157.43"
+           y="32.417"
+           width="22.49"
+           height="6.6146"
+           fill="#d7d7f4"
+           id="rect46" />
+      </g>
+      <rect
+         x="44.979"
+         y="46.969"
+         width="22.49"
+         height="6.6146"
+         fill="#f4d7d7"
+         stroke-dasharray="0.52999997, 0.26499999"
+         stroke-width=".265"
+         id="rect50" />
+    </g>
+    <text
+       x="56.412949"
+       y="51.598957"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="10.583px"
+       letter-spacing="0px"
+       stroke-width="0.26458"
+       word-spacing="0px"
+       style="line-height:1.25"
+       xml:space="preserve"
+       id="text56"><tspan
+         x="56.412949"
+         y="51.598957"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         stroke-width="0.26458"
+         text-align="center"
+         text-anchor="middle"
+         style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         id="tspan54">26f9a7...</tspan></text>
+    <rect
+       x="67.469"
+       y="46.969"
+       width="22.49"
+       height="6.6146"
+       fill="#f4d7d7"
+       stroke="#000"
+       stroke-dasharray="0.52999997, 0.26499999"
+       stroke-width=".265"
+       id="rect58" />
+    <text
+       x="78.902527"
+       y="51.598961"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="10.583px"
+       letter-spacing="0px"
+       stroke-width="0.26458"
+       word-spacing="0px"
+       style="line-height:1.25"
+       xml:space="preserve"
+       id="text62"><tspan
+         x="78.902527"
+         y="51.598961"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         stroke-width="0.26458"
+         text-align="center"
+         text-anchor="middle"
+         style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         id="tspan60">b44ab3...</tspan></text>
+    <rect
+       x="89.958"
+       y="46.969"
+       width="22.49"
+       height="6.6146"
+       fill="#f4d7d7"
+       stroke="#000"
+       stroke-dasharray="0.52999997, 0.26499999"
+       stroke-width=".265"
+       id="rect64" />
+    <text
+       x="101.39211"
+       y="51.598961"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="10.583px"
+       letter-spacing="0px"
+       stroke-width="0.26458"
+       word-spacing="0px"
+       style="line-height:1.25"
+       xml:space="preserve"
+       id="text68"><tspan
+         x="101.39211"
+         y="51.598961"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         stroke-width="0.26458"
+         text-align="center"
+         text-anchor="middle"
+         style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         id="tspan66">ee5593...</tspan></text>
+    <rect
+       x="112.45"
+       y="46.969"
+       width="22.49"
+       height="6.6146"
+       fill="#f4d7d7"
+       stroke="#000"
+       stroke-dasharray="0.52999997, 0.26499999"
+       stroke-width=".265"
+       id="rect70" />
+    <text
+       x="123.88169"
+       y="51.598961"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="10.583px"
+       letter-spacing="0px"
+       stroke-width="0.26458"
+       word-spacing="0px"
+       style="line-height:1.25"
+       xml:space="preserve"
+       id="text74"><tspan
+         x="123.88169"
+         y="51.598961"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         stroke-width="0.26458"
+         text-align="center"
+         text-anchor="middle"
+         style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         id="tspan72">7a3bfe...</tspan></text>
+    <rect
+       x="134.94"
+       y="46.969"
+       width="22.49"
+       height="6.6146"
+       fill="#f4d7d7"
+       stroke="#000"
+       stroke-dasharray="0.52999997, 0.26499999"
+       stroke-width=".265"
+       id="rect76" />
+    <text
+       x="146.37128"
+       y="51.598957"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="10.583px"
+       letter-spacing="0px"
+       stroke-width="0.26458"
+       word-spacing="0px"
+       style="line-height:1.25"
+       xml:space="preserve"
+       id="text80"><tspan
+         x="146.37128"
+         y="51.598957"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         stroke-width="0.26458"
+         text-align="center"
+         text-anchor="middle"
+         style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         id="tspan78">8f4e15...</tspan></text>
+    <rect
+       x="157.43"
+       y="46.969"
+       width="22.49"
+       height="6.6146"
+       fill="#f4d7d7"
+       stroke="#000"
+       stroke-dasharray="0.52999997, 0.26499999"
+       stroke-width=".265"
+       id="rect82" />
+    <g
+       font-family="sans-serif"
+       letter-spacing="0px"
+       stroke-width=".26458"
+       word-spacing="0px"
+       id="g98">
+      <text
+         x="168.86086"
+         y="51.598961"
+         font-size="10.583px"
+         style="line-height:1.25"
+         xml:space="preserve"
+         id="text86"><tspan
+           x="168.86086"
+           y="51.598961"
+           font-family="sans-serif"
+           font-size="3.5278px"
+           stroke-width="0.26458"
+           text-align="center"
+           text-anchor="middle"
+           style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+           id="tspan84">40c285...</tspan></text>
+      <text
+         x="6.6430736"
+         y="51.680019"
+         font-size="3.5278px"
+         style="line-height:1.25;font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         xml:space="preserve"
+         id="text90"><tspan
+           x="6.6430736"
+           y="51.680019"
+           stroke-width="0.26458"
+           id="tspan88">read-only bdev</tspan></text>
+      <text
+         x="6.6296382"
+         y="12.539818"
+         font-size="3.5278px"
+         style="line-height:1.25;font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         xml:space="preserve"
+         id="text96"><tspan
+           sodipodi:role="line"
+           id="tspan436"
+           x="6.6296382"
+           y="12.539818">esnap clone</tspan><tspan
+           sodipodi:role="line"
+           x="6.6296382"
+           y="16.949568"
+           id="tspan440">Volume</tspan><tspan
+           sodipodi:role="line"
+           id="tspan438"
+           x="6.6296382"
+           y="21.359318" /></text>
+    </g>
+    <g
+       stroke="#000"
+       id="g118">
+      <path
+         d="m6.6146 24.479 173.3 1e-6"
+         fill="none"
+         stroke-dasharray="1.59, 1.59"
+         stroke-width=".265"
+         id="path100" />
+      <g
+         fill="#f4d7d7"
+         stroke-dasharray="0.52916663, 0.26458332"
+         stroke-width=".26458"
+         id="g108">
+        <rect
+           x="44.979"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect102" />
+        <rect
+           x="112.45"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect104" />
+        <rect
+           x="134.94"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect106" />
+      </g>
+      <g
+         fill="#d7d7f4"
+         stroke-width=".26458"
+         id="g116">
+        <rect
+           x="67.469"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect110" />
+        <rect
+           x="89.958"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect112" />
+        <rect
+           x="157.43"
+           y="9.9271"
+           width="22.49"
+           height="6.6146"
+           id="rect114" />
+      </g>
+    </g>
+    <text
+       x="6.614583"
+       y="37.708332"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="3.5278px"
+       letter-spacing="0px"
+       stroke-width=".26458"
+       word-spacing="0px"
+       style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal;line-height:1.25"
+       xml:space="preserve"
+       id="text122"><tspan
+         x="6.614583"
+         y="37.708332"
+         stroke-width=".26458"
+         id="tspan120">active clusters</tspan></text>
+    <rect
+       x="37.042"
+       y="7.2812"
+       width="145.52"
+       height="11.906"
+       ry="1.3229"
+       fill="none"
+       stroke="#999"
+       stroke-width=".5"
+       id="rect124" />
+    <rect
+       x="37.042"
+       y="29.771"
+       width="145.52"
+       height="26.458"
+       ry="1.3229"
+       fill="none"
+       stroke="#999"
+       stroke-width=".5"
+       id="rect126" />
+    <g
+       fill="#00f"
+       stroke="#00f"
+       id="g144">
+      <g
+         stroke-width=".26458"
+         id="g140">
+        <path
+           d="m78.052 16.542v15.875"
+           marker-end="url(#marker1960)"
+           id="path128" />
+        <path
+           d="m55.562 16.542v30.427"
+           marker-end="url(#marker2036)"
+           id="path130" />
+        <path
+           d="m100.54 16.542v15.875"
+           marker-end="url(#marker1890)"
+           id="path132" />
+        <path
+           d="m169.33 16.542v15.875"
+           marker-end="url(#Arrow1Mend)"
+           id="path134" />
+        <path
+           d="m124.35 16.542v30.427"
+           marker-end="url(#marker1826)"
+           id="path136" />
+        <path
+           d="m146.84 16.542v30.427"
+           marker-end="url(#marker1816)"
+           id="path138" />
+      </g>
+      <path
+         d="m132.29 61.521 10.583 1e-5"
+         marker-end="url(#marker1826-2-4-7-1-7)"
+         stroke-width=".265"
+         id="path142" />
+    </g>
+    <path
+       d="m132.29 66.813h10.583"
+       fill="#f00"
+       marker-end="url(#marker11771-4-9)"
+       stroke="#ff2a2a"
+       stroke-width=".265"
+       id="path146" />
+    <g
+       stroke-width=".26458"
+       id="g162">
+      <text
+         x="145.52083"
+         y="62.843975"
+         fill="#000000"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         letter-spacing="0px"
+         word-spacing="0px"
+         style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal;line-height:1.25"
+         xml:space="preserve"
+         id="text150"><tspan
+           x="145.52083"
+           y="62.843975"
+           font-family="sans-serif"
+           font-size="2.8222px"
+           stroke-width=".26458"
+           style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal"
+           id="tspan148">read</tspan></text>
+      <text
+         x="145.52083"
+         y="68.135651"
+         fill="#000000"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         letter-spacing="0px"
+         word-spacing="0px"
+         style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal;line-height:1.25"
+         xml:space="preserve"
+         id="text154"><tspan
+           x="145.52083"
+           y="68.135651"
+           font-family="sans-serif"
+           font-size="2.8222px"
+           stroke-width=".26458"
+           style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal"
+           id="tspan152">allocate and copy cluster</tspan></text>
+      <rect
+         x="132.29"
+         y="70.781"
+         width="10.583"
+         height="2.6458"
+         fill="none"
+         stroke="#000"
+         stroke-dasharray="0.52916664, 0.52916664"
+         id="rect156" />
+      <text
+         x="145.52083"
+         y="73.427307"
+         fill="#000000"
+         font-family="sans-serif"
+         font-size="3.5278px"
+         letter-spacing="0px"
+         word-spacing="0px"
+         style="line-height:1.25;font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+         xml:space="preserve"
+         id="text160"><tspan
+           x="145.52083"
+           y="73.427307"
+           font-family="sans-serif"
+           font-size="2.8222px"
+           stroke-width="0.26458"
+           style="font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-feature-settings:normal"
+           id="tspan158">external snapshot cluster</tspan></text>
+    </g>
+    <rect
+       x="132.29"
+       y="76.073"
+       width="10.583"
+       height="2.6458"
+       fill="none"
+       stroke="#000"
+       stroke-width=".265"
+       id="rect164" />
+    <text
+       x="145.52083"
+       y="78.718971"
+       fill="#000000"
+       font-family="sans-serif"
+       font-size="3.5278px"
+       letter-spacing="0px"
+       stroke-width=".26458"
+       word-spacing="0px"
+       style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal;line-height:1.25"
+       xml:space="preserve"
+       id="text168"><tspan
+         x="145.52083"
+         y="78.718971"
+         font-family="sans-serif"
+         font-size="2.8222px"
+         stroke-width=".26458"
+         style="font-feature-settings:normal;font-variant-caps:normal;font-variant-ligatures:normal;font-variant-numeric:normal"
+         id="tspan166">allocated cluster</tspan></text>
+  </g>
+</svg>

doc/img/ublk_service.svg

@@ -0,0 +1,41 @@
+<?xml version="1.0"?>
+<svg width="680" height="420" xmlns="http://www.w3.org/2000/svg" xmlns:svg="http://www.w3.org/2000/svg">
+ <!-- Created with SVG-edit - https://github.com/SVG-Edit/svgedit-->
+ <g class="layer">
+  <title>Layer 1</title>
+  <rect fill="#ffffff" height="369" id="svg_1" stroke="#000000" width="635.87" x="22.74" y="26.61"/>
+  <rect fill="#aaffff" height="0" id="svg_2" stroke="#000000" width="0" x="191.24" y="101.36">Application A</rect>
+  <rect fill="#aaffff" height="88.96" id="svg_3" stroke="#000000" width="171" x="400.9" y="67.61">ublk Server</rect>
+  <line fill="none" id="svg_4" stroke="#000000" stroke-dasharray="5,5" stroke-width="2" x1="23.11" x2="660.11" y1="199.03" y2="198.03">ublk Server</line>
+  <text fill="#000000" font-family="Serif" font-size="21" font-weight="bold" id="svg_5" stroke="#000000" stroke-width="0" text-anchor="middle" transform="matrix(1 0 0 1 0 0)" x="488.28" xml:space="preserve" y="122.24">ublk Server</text>
+  <rect fill="#aaffff" height="62" id="svg_6" stroke="#000000" transform="matrix(1 0 0 1 0 0)" width="161" x="384.38" y="311.2"/>
+  <text fill="#000000" font-family="Serif" font-size="21" font-weight="bold" id="svg_7" stroke="#000000" stroke-width="0" text-anchor="middle" transform="matrix(1 0 0 1 0 0)" x="468.93" xml:space="preserve" y="349.7">ublk Driver</text>
+  <rect fill="#ffff00" height="32" id="svg_8" stroke="#000000" width="98" x="144.36" y="212.94"/>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_9" stroke="#000000" stroke-width="0" text-anchor="middle" x="194.36" xml:space="preserve" y="235.94">/dev/ublkb3</text>
+  <rect fill="#ffffff" height="0" id="svg_10" stroke="#000000" width="0" x="175.36" y="246.94"/>
+  <rect fill="#ffff00" height="33" id="svg_11" stroke="#000000" width="97" x="200.03" y="239.6"/>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_12" stroke="#000000" stroke-width="0" text-anchor="middle" x="249.36" xml:space="preserve" y="263.27">/dev/ublkb2</text>
+  <rect fill="#ffffff" height="0" id="svg_13" stroke="#000000" width="0" x="174.36" y="264.94"/>
+  <rect fill="#ffff00" height="33" id="svg_14" stroke="#000000" width="97" x="33.99" y="244.06"/>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_15" stroke="#000000" stroke-width="0" text-anchor="middle" x="82.99" xml:space="preserve" y="267.06">/dev/ublkb1</text>
+  <rect fill="#00ff00" height="32" id="svg_16" stroke="#000000" width="93" x="35.99" y="206.31">le/dev/ublkb1</rect>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_17" stroke="#000000" stroke-width="0" text-anchor="middle" x="80.99" xml:space="preserve" y="226.31">Filesystem</text>
+  <path d="m383.94,359.38l-298.65,-1.66c0,0 -1.68,-79.96 -1.68,-79.96" fill="none" id="svg_22" stroke="#000000" stroke-linejoin="bevel" stroke-width="4"/>
+  <path d="m384.83,334.28l-148.14,-0.2c0,0 3.33,-62.12 3.33,-62.12" fill="none" id="svg_26" stroke="#000000" stroke-linejoin="bevel" stroke-width="4" transform="matrix(1 0 0 1 0 0)"/>
+  <path d="m384.69,347.33l-201.99,-0.22l0,-102.04" fill="none" id="svg_27" stroke="#000000" stroke-linejoin="bevel" stroke-width="4" transform="matrix(1 0 0 1 0 0)"/>
+  <path d="m454.33,155.75c0,0 0.48,154.94 0.32,154.69c-0.16,-0.25 -0.32,-154.69 -0.32,-154.69z" fill="none" id="svg_28" stroke="#000000" stroke-linejoin="bevel" stroke-width="3"/>
+  <path d="m468.6,156.42l0.18,155.99l-0.18,-155.99z" fill="none" id="svg_29" stroke="#000000" stroke-linejoin="bevel" stroke-width="3"/>
+  <path d="m482.69,157.08l-0.32,154.03l0.32,-154.03z" fill="none" id="svg_30" stroke="#000000" stroke-linecap="square" stroke-linejoin="bevel" stroke-width="3">ublk Server</path>
+  <rect fill="#aaffff" height="35.63" id="svg_40" stroke="#000000" width="109.37" x="65.74" y="91.86">Application A</rect>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_41" stroke="#000000" stroke-width="0" style="cursor: move;" text-anchor="middle" x="119.36" xml:space="preserve" y="112.19">Application D</text>
+  <rect fill="#aaffff" height="30.63" id="svg_42" stroke="#000000" width="109.37" x="89.49" y="115.61">Application A</rect>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_43" stroke="#000000" stroke-width="0" text-anchor="middle" x="143.11" xml:space="preserve" y="136.56">Application C</text>
+  <rect fill="#aaffff" height="31.25" id="svg_44" stroke="#000000" width="109.37" x="114.49" y="139.99">Application A</rect>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_45" stroke="#000000" stroke-width="0" style="cursor: move;" text-anchor="middle" x="169.36" xml:space="preserve" y="160.31">Application B</text>
+  <rect fill="#aaffff" height="30.63" id="svg_46" stroke="#000000" width="109.37" x="145.74" y="164.99">Application A</rect>
+  <text fill="#000000" font-family="Serif" font-size="18" id="svg_47" stroke="#000000" stroke-width="0" text-anchor="middle" x="201.24" xml:space="preserve" y="186.56">Application A</text>
+  <text fill="#000000" font-family="Serif" font-size="21" font-weight="bold" id="svg_50" stroke="#000000" stroke-width="0" text-anchor="middle" transform="matrix(1 0 0 1 0 0)" x="161.4" xml:space="preserve" y="82.24">ublk Workload</text>
+  <text fill="#000000" font-family="Serif" font-size="19" font-style="italic" font-weight="normal" id="svg_51" stroke="#000000" stroke-width="0" text-anchor="middle" x="602.65" xml:space="preserve" y="222.24">Kernel Space</text>
+  <text fill="#000000" font-family="Serif" font-size="19" font-style="italic" font-weight="normal" id="svg_52" stroke="#000000" stroke-width="0" text-anchor="middle" transform="matrix(1 0 0 1 0 0)" x="602.03" xml:space="preserve" y="188.49">Userspace</text>
+ </g>
+</svg>

doc/lvol.md

@@ -74,6 +74,18 @@ A snapshot can be removed only if there is a single clone on top of it. The rela
 The cluster map of clone and snapshot will be merged and entries for unallocated clusters in the clone will be updated with
 addresses from the snapshot cluster map. The entire operation modifies metadata only - no data is copied during this process.
 
+### External Snapshots
+
+With the external snapshots feature, clones can be made of any bdev. These clones are commonly called *esnap clones*.
+Esnap clones work very similarly to thin provisioning. Rather than the back device being an zeroes device, the external snapshot
+bdev is used as the back device.
+
+![Clone of External Snapshot](lvol_esnap_clone.svg)
+
+A bdev that is used as an external snapshot cannot be opened for writing by anything else so long as an esnap clone exists.
+
+A bdev may have multiple esnap clones and esnap clones can themselves be snapshotted and cloned.
+
 ### Inflation {#lvol_inflation}
 
 Blobs can be inflated to copy data from backing devices (e.g. snapshots) and allocate all remaining clusters. As a result of this
@@ -138,6 +150,12 @@ bdev_lvol_create [-h] [-u UUID] [-l LVS_NAME] [-t] [-c CLEAR_METHOD] lvol_name s
     optional arguments:
     -h, --help  show help
     -c, --clear-method specify data clusters clear method "none", "unmap" (default), "write_zeroes"
+bdev_lvol_get_lvols [-h] [-u LVS_UUID] [-l LVS_NAME]
+    Display logical volume list, including those that do not have associated bdevs.
+    optional arguments:
+    -h, --help  show help
+    -u LVS_UUID, --lvs_uuid UUID  show volumes only in the specified lvol store
+    -l LVS_NAME, --lvs_name LVS_NAME  show volumes only in the specified lvol store
 bdev_get_bdevs [-h] [-b NAME]
     User can view created bdevs using this call including those created on top of lvols.
     optional arguments:
@@ -155,6 +173,10 @@ bdev_lvol_clone [-h] snapshot_name clone_name
     Create a clone with clone_name of a given lvol snapshot.
     optional arguments:
     -h, --help  show help
+bdev_lvol_clone_bdev [-h] bdev_name_or_uuid lvs_name clone_name
+    Create a clone with clone_name of a bdev. The bdev must not be an lvol in the lvs_name lvstore.
+    optional arguments:
+    -h, --help  show help
 bdev_lvol_rename [-h] old_name new_name
     Change lvol bdev name
     optional arguments:
@@ -175,4 +197,12 @@ bdev_lvol_decouple_parent [-h] name
     Decouple parent of a logical volume
     optional arguments:
     -h, --help  show help
+bdev_lvol_set_xattr [-h] name xattr_name xattr_value
+    Set xattr for lvol bdev
+    optional arguments:
+    -h, --help  show help
+bdev_lvol_get_xattr [-h] name xattr_name
+    Get xattr for lvol bdev
+    optional arguments:
+    -h, --help  show help
 ```

doc/nvme.md

@@ -10,6 +10,7 @@
 - @ref nvme_multi_process
 - @ref nvme_hotplug
 - @ref nvme_cuse
+- @ref nvme_led
 
 ## Introduction {#nvme_intro}
 
@@ -302,8 +303,6 @@ At the NVMe driver level, we provide the following support for Hotplug:
 
 ## NVMe Character Devices {#nvme_cuse}
 
-This feature is considered as experimental.
-
 ### Design
 
 ![NVMe character devices processing diagram](nvme_cuse.svg)
@@ -408,3 +407,12 @@ with SPDK NVMe CUSE.
 
 SCSI to NVMe Translation Layer is not implemented. Tools that are using this layer to
 identify, manage or operate device might not work properly or their use may be limited.
+
+## NVMe LED management {#nvme_led}
+
+It is possible to use the ledctl(8) utility to control the state of LEDs in systems supporting
+NPEM (Native PCIe Enclosure Management), even when the NVMe devices are controlled by SPDK.
+However, in this case it is necessary to determine the slot device number because the block device
+is unavailable. The [ledctl.sh](https://github.com/spdk/spdk/tree/master/scripts/ledctl.sh) script
+can be used to help with this. It takes the name of the nvme bdev and invokes ledctl with
+appropriate options.

doc/nvme_multipath.md

@@ -0,0 +1,166 @@
+# NVMe Multipath {#nvme_multipath}
+
+## Introduction
+
+The NVMe bdev module supports two modes: failover and multipath. In failover mode, only one
+active connection is maintained and alternate paths are connected only during the switch-over.
+This can lead to delays and failed I/O reported to upper layers, but it does reduce the number
+of active connections at any given time. In multipath, active connections are maintained for
+every path and used based on a policy of either active-passive or active-active. The multipath
+mode also supports Asymmetric Namespace Access (ANA) and uses that to make policy decisions.
+
+## Design
+
+### Multipath Mode
+
+A user may establish connections on multiple independent paths to the same NVMe-oF subsystem
+for NVMe bdevs by calling the `bdev_nvme_attach_controller` RPC multiple times with the same NVMe
+bdev controller name. Additionally, the `multipath` parameter for this RPC must be set to
+"multipath" when connecting the second or later paths.
+
+For each path created by the `bdev_nvme_attach_controller` RPC, an NVMe-oF controller is created.
+Then the set of namespaces presented by that controller are discovered. For each namespace found,
+the NVMe bdev module attempts to match it with an existing NVMe bdev. If it finds a match, it adds
+the given namespace as an alternate path. If it does not find a match, it creates a new NVMe bdev.
+
+I/O and admin qpairs are necessary to access an NVMe-oF controller. A single admin qpair is created
+and is shared by all SPDK threads. To submit I/O without taking locks, for each SPDK thread, an I/O
+qpair is created as a dynamic context of an I/O channel for an NVMe-oF controller.
+
+For each SPDK thread, the NVMe bdev module creates an I/O channel for an NVMe bdev and provides it to
+the upper layer. The I/O channel for the NVMe bdev has an I/O path for each namespace. I/O path is
+an additional abstraction to submit I/O to a namespace, and consists of an I/O qpair context and a
+namespace. If an NVMe bdev has multiple namespaces, an I/O channel for the NVMe bdev has a list of
+multiple I/O paths. The I/O channel for the NVMe bdev has a retry I/O list and has a path selection
+policy.
+
+### Path Error Recovery
+
+If the NVMe driver detects an error on a qpair, it disconnects the qpair and notifies the error to
+the NVMe bdev module. Then the NVMe bdev module starts resetting the corresponding NVMe-oF controller.
+The NVMe-oF controller reset consists of the following steps: 1) disconnect and delete all I/O qpairs,
+2) disconnect admin qpair, 3) connect admin qpair, 4) configure the NVMe-oF controller, and
+5) create and connect all I/O qpairs.
+
+If the step 3, 4, or 5 fails, the reset reverts to the step 3 and then it is retried after
+`reconnect_delay_sec` seconds. Then the NVMe-oF controller is deleted automatically if it is not
+recovered within `ctrlr_loss_timeout_sec` seconds. If `ctrlr_loss_timeout_sec` is -1, it retries
+indefinitely.
+
+By default, error detection on a qpair is very slow for TCP and RDMA transports. For fast error
+detection, a global option, `transport_ack_timeout`, is useful.
+
+### Path Selection
+
+Multipath mode supports two path selection policies, active-passive or active-active.
+
+For both path selection policies, only ANA optimal I/O paths are used unless there are no ANA
+optimal I/O paths available.
+
+For active-passive policy, each I/O channel for an NVMe bdev has a cache to store the first found
+I/O path which is connected and optimal from ANA and use it for I/O submission. Some users may want
+to specify the preferred I/O path manually. They can dynamically set the preferred I/O path using
+the `bdev_nvme_set_preferred_path` RPC. Such assignment is realized naturally by moving the
+I/O path to the head of the I/O path list. By default, if the preferred I/O path is restored,
+failback to it is done automatically. The automatic failback can be disabled by a global option
+`disable_auto_failback`. In this case, the `bdev_nvme_set_preferred_path` RPC can be used
+to do manual failback.
+
+The active-active policy uses the round-robin algorithm and submits an I/O to each I/O path in
+circular order.
+
+### I/O Retry
+
+The NVMe bdev module has a global option, `bdev_retry_count`, to control the number of retries when
+an I/O is returned with error. Each I/O has a retry count. If the retry count of an I/O is less than
+the `bdev_retry_count`, the I/O is allowed to retry and the retry count is incremented.
+
+NOTE: The `bdev_retry_count` is not directly used but is required to be non-zero for the process
+of multipath mode failing over to a different path because the retry count is checked first always
+when an I/O is returned with error.
+
+Each I/O has a timer to schedule an I/O retry at a particular time in the future. Each I/O channel
+for an NVMe bdev has a sorted I/O retry list. Retried I/Os are inserted into the I/O retry list.
+
+If an I/O is returned with error, the I/O completion handler in the NVMe bdev module executes the
+following steps:
+
+1. If the DNR (Do Not Retry) bit is set or the retry count exceeds the limit, then complete the
+   I/O with the returned error.
+2. If the error is a path error, insert the I/O to the I/O retry list with no delay.
+3. Otherwise, insert the I/O to the I/O retry list with the delay reported by the CRD (Command
+   Retry Delay).
+
+Then the I/O retry poller is scheduled to the closest expiration. If there is no retried I/O,
+the I/O retry poller is stopped.
+
+When submitting an I/O, there may be no available I/O path. If there is any I/O path which is
+recovering, the I/O is inserted to the I/O retry list with one second delay. This may result in
+queueing many I/Os indefinitely. To avoid such indefinite queueing, per NVMe-oF controller option,
+`fast_io_fail_timeout_sec`, is added. If the corresponding NVMe-oF controller is not recovered
+within `fast_io_fail_timeout_sec` seconds, the I/O is not queued to wait the recovery but returned
+with an I/O error to the upper layer.
+
+### Asymmetric Namespace Accesses (ANA) Handling
+
+If an I/O is returned with an ANA error or an ANA change notice event is received, the ANA log page
+may be changed. In this case, the NVMe bdev module reads the ANA log page to check the ANA state
+changes.
+
+As described before, only ANA optimal I/O paths will be used unless there are no ANA optimal paths
+available.
+
+If an I/O path is in ANA transition, i.e., its namespace reports the ANA inaccessible state or the ANA
+change state, the NVMe bdev module queues I/Os to wait until the namespace becomes accessible again.
+The ANA transition should end within the ANATT (ANA Transition Time) seconds. If the namespace does
+not report the ANA optimized state or the ANA accessible state within the ANATT seconds, I/Os are
+returned with an I/O error to the upper layer.
+
+### I/O Timeout
+
+The NVMe driver supports I/O timeout for submitted I/Os. The NVMe bdev module provides three
+actions when an I/O timeout is notified from the NVMe driver, ABORT, RESET, or NONE. Users can
+choose one of the actions as a global option, `action_on_timeout`. Users can set different timeout
+values for I/O commands and admin commands by global options, `timeout_us` and `timeout_admin_us`.
+
+For ABORT, the NVMe bdev module tries aborting the timed out I/O, and if failed, it starts the
+NVMe-oF controller reset. For RESET, the NVMe bdev module starts the NVMe-oF controller reset.
+
+## Usage
+
+The following is an example to attach two NVMe-oF controllers and aggregate these into a single
+NVMe bdev controller `Nvme0`.
+
+```bash
+./scripts/rpc.py bdev_nvme_attach_controller -b Nvme0 -t rdma -a 192.168.100.8 -s 4420 -f ipv4 -n nqn.2016-06.io.spdk:cnode1 -l -1 -o 20
+./scripts/rpc.py bdev_nvme_attach_controller -b Nvme0 -t rdma -a 192.168.100.9 -s 4420 -f ipv4 -n nqn.2016-06.io.spdk:cnode1 -l -1 -o 20 -x multipath
+```
+
+In this example, if these two NVMe-oF controllers have a shared namespace whose namespace ID is 1,
+a single NVMe bdev `Nvme0n1` is created. For the NVMe bdev module, the default value of
+`bdev_retry_count` is 3 and I/O retry is enabled by default. `ctrlr_loss_timeout_sec` is set to -1
+and `reconnect_delay_sec` is set to 20. Hence, NVMe-oF controller reconnect will be retried once
+per 20 seconds until it succeeds.
+
+To confirm if multipath is configured correctly, two RPCs, `bdev_get_bdevs` and
+`bdev_nvme_get_controllers` are available.
+
+```bash
+./scripts/rpc.py bdev_get_bdevs -b Nvme0n1
+./scripts/rpc.py bdev_nvme_get_controllers -n Nvme0
+```
+
+To monitor the current multipath state, a RPC `bdev_nvme_get_io_paths` are available.
+
+```bash
+./scripts/rpc.py bdev_nvme_get_io_paths -n Nvme0n1
+```
+
+## Limitations
+
+SPDK NVMe multipath is transport protocol independent. Heterogeneous multipath configuration (e.g.,
+TCP and RDMA) is supported. However, in this type of configuration, memory domain is not available
+yet because memory domain is supported only by the RDMA transport now.
+
+The RPCs, `bdev_get_iostat` and  `bdev_nvme_get_transport_statistics` display I/O statistics but
+both are not aware of multipath.

doc/nvmf.md

@@ -130,11 +130,9 @@ After cloning SPDK repo and initialize submodules, FC LLD library is built which
 the fc transport.
 
 ~~~{.sh}
-git clone https://github.com/spdk/spdk spdk
+git clone https://github.com/spdk/spdk --recursive
 git clone https://github.com/ecdufcdrvr/bcmufctdrvr fc
-cd spdk
+cd fc
-git submodule update --init
-cd ../fc
 make DPDK_DIR=../spdk/dpdk/build SPDK_DIR=../spdk
 cd ../spdk
 ./configure --with-fc=../fc/build
@@ -152,13 +150,13 @@ working with NVMe over Fabrics specific RPCs can be found on the @ref jsonrpc_co
 Start the nvmf_tgt application with elevated privileges. Once the target is started,
 the nvmf_create_transport rpc can be used to initialize a given transport. Below is an
 example where the target is started and configured with two different transports.
-The RDMA transport is configured with an I/O unit size of 8192 bytes, 4 max qpairs per controller,
+The RDMA transport is configured with an I/O unit size of 8192 bytes, max I/O size 131072 and an
-and an in capsule data size of 0 bytes. The TCP transport is configured with an I/O unit size of
+in capsule data size of 8192 bytes. The TCP transport is configured with an I/O unit size of
 16384 bytes, 8 max qpairs per controller, and an in capsule data size of 8192 bytes.
 
 ~~~{.sh}
 build/bin/nvmf_tgt
-scripts/rpc.py nvmf_create_transport -t RDMA -u 8192 -m 4 -c 0
+scripts/rpc.py nvmf_create_transport -t RDMA -u 8192 -i 131072 -c 8192
 scripts/rpc.py nvmf_create_transport -t TCP -u 16384 -m 8 -c 8192
 ~~~
 
@@ -270,3 +268,8 @@ nvme disconnect -n "nqn.2016-06.io.spdk:cnode1"
 
 SPDK has a tracing framework for capturing low-level event information at runtime.
 @ref nvmf_tgt_tracepoints enable analysis of both performance and application crashes.
+
+## Enabling NVMe-oF Multipath
+
+The SPDK NVMe-oF target and initiator support multiple independent paths to the same NVMe-oF subsystem.
+For step-by-step instructions for configuring and switching between paths, see @ref nvmf_multipath_howto .

doc/nvmf_multipath_howto.md

@@ -0,0 +1,103 @@
+# NVMe-oF Multipath HOWTO {#nvmf_multipath_howto}
+
+This HOWTO provides step-by-step instructions for setting-up a simple SPDK deployment and testing multipath.
+It demonstrates configuring path preferences with Asymmetric Namespace Access (ANA), as well as round-robin
+path load balancing.
+
+## Build SPDK on both the initiator and target servers
+
+Clone the repo:
+~~~{.sh}
+git clone https://github.com/spdk/spdk --recursive
+~~~
+
+Configure and build SPDK:
+~~~{.sh}
+cd spdk/
+./configure
+make -j16
+~~~
+
+## Setup hugepages
+
+This should be run once on each server (and after reboots):
+~~~{.sh}
+cd spdk/
+./scripts/setup.sh
+~~~
+
+## On target: start and configure SPDK
+
+Start the target in the background and configure it:
+~~~{.sh}
+cd spdk/
+./build/bin/nvmf_tgt -m 0x3 &
+./scripts/rpc.py nvmf_create_transport -t tcp -o -u 8192
+~~~
+
+Create a subsystem, with `-r` to enable ANA reporting feature:
+~~~{.sh}
+./scripts/rpc.py nvmf_create_subsystem nqn.2022-02.io.spdk:cnode0 -a -s SPDK00000000000001 -r
+~~~
+
+Create and add a malloc block device:
+~~~{.sh}
+./scripts/rpc.py bdev_malloc_create 64 512 -b Malloc0
+./scripts/rpc.py nvmf_subsystem_add_ns nqn.2022-02.io.spdk:cnode0 Malloc0
+~~~
+
+Add two listeners, each with a different `IP:port` pair:
+~~~{.sh}
+./scripts/rpc.py nvmf_subsystem_add_listener -t tcp -a 172.17.1.13 -s 4420 nqn.2022-02.io.spdk:cnode0
+./scripts/rpc.py nvmf_subsystem_add_listener -t tcp -a 172.18.1.13 -s 5520 nqn.2022-02.io.spdk:cnode0
+~~~
+
+## On initiator: start and configure bdevperf
+
+Launch the bdevperf process in the background:
+~~~{.sh}
+cd spdk/
+./build/examples/bdevperf -m 0x4 -z -r /tmp/bdevperf.sock -q 128 -o 4096 -w verify -t 90 &> bdevperf.log &
+~~~
+
+Configure bdevperf and add two paths:
+~~~{.sh}
+./scripts/rpc.py -s /tmp/bdevperf.sock bdev_nvme_set_options -r -1
+./scripts/rpc.py -s /tmp/bdevperf.sock bdev_nvme_attach_controller -b Nvme0 -t tcp -a 172.17.1.13 -s 4420 -f ipv4 -n nqn.2022-02.io.spdk:cnode0 -l -1 -o 10
+./scripts/rpc.py -s /tmp/bdevperf.sock bdev_nvme_attach_controller -b Nvme0 -t tcp -a 172.18.1.13 -s 5520 -f ipv4 -n nqn.2022-02.io.spdk:cnode0 -x multipath -l -1 -o 10
+~~~
+
+## Launch a bdevperf test
+
+Connect to the RPC socket of the bdevperf process and start the test:
+~~~{.sh}
+PYTHONPATH=$PYTHONPATH:/root/src/spdk/python ./examples/bdev/bdevperf/bdevperf.py -t 1 -s /tmp/bdevperf.sock perform_tests
+~~~
+
+The RPC command will return, leaving the test to run for 90 seconds in the background. On the target server,
+observe that only the first path (port) is receiving packets by checking the queues with `ss -t`.
+
+You can view the paths available to the initiator with:
+~~~{.sh}
+./scripts/rpc.py -s /tmp/bdevperf.sock bdev_nvme_get_io_paths -n Nvme0n1
+~~~
+
+## Switching paths
+
+This can be done on the target server by setting the first path's ANA to `non_optimized`:
+~~~{.sh}
+./scripts/rpc.py nvmf_subsystem_listener_set_ana_state nqn.2022-02.io.spdk:cnode0 -t tcp -a 172.17.1.13 -s 4420 -n non_optimized
+~~~
+
+Use `ss -t`  to verify that the traffic has switched to the second path.
+
+## Use round-robin (active_active) path load balancing
+
+First, ensure the ANA for both paths is configured as `optimized` on the target. Then, change the
+multipath policy on the initiator to `active_active` (multipath policy is per bdev, so
+`bdev_nvme_set_multipath_policy` must be called after `bdev_nvme_attach_controller`):
+~~~{.sh}
+./scripts/rpc.py -s /tmp/bdevperf.sock bdev_nvme_set_multipath_policy -b Nvme0n1 -p active_active
+~~~
+
+Observe with `ss -t` that both connections are receiving traffic (queues build up).

doc/nvmf_tracing.md

@@ -205,6 +205,7 @@ define the tracepoints and assigning them a unique ID using the SPDK_TPOINT_ID m
 ~~~c
 #define	TRACE_GROUP_NVMF_RDMA	0x4
 #define TRACE_RDMA_REQUEST_STATE_NEW	SPDK_TPOINT_ID(TRACE_GROUP_NVMF_RDMA, 0x0)
+#define TRACE_RDMA_REQUEST_STATE_NEED_BUFFER	SPDK_TPOINT_ID(TRACE_GROUP_NVMF_RDMA, 0x1)
 ...
 #define NEW_TRACE_POINT_NAME	SPDK_TPOINT_ID(TRACE_GROUP_NVMF_RDMA, UNIQUE_ID)
 ~~~
@@ -214,18 +215,16 @@ within the application/library using the spdk_trace_register_description functio
 as shown below:
 
 ~~~c
-SPDK_TRACE_REGISTER_FN(nvmf_trace)
+SPDK_TRACE_REGISTER_FN(nvmf_trace, "nvmf_rdma", TRACE_GROUP_NVMF_RDMA)
 {
 	spdk_trace_register_object(OBJECT_NVMF_RDMA_IO, 'r');
-	spdk_trace_register_description("RDMA_REQ_NEW", "",
+	spdk_trace_register_description("RDMA_REQ_NEW", TRACE_RDMA_REQUEST_STATE_NEW,
-					TRACE_RDMA_REQUEST_STATE_NEW,
 					OWNER_NONE, OBJECT_NVMF_RDMA_IO, 1,
-					SPDK_TRACE_ARG_TYPE_PTR, "cmid:	");
+					SPDK_TRACE_ARG_TYPE_PTR, "qpair");
-	...
+	spdk_trace_register_description("RDMA_REQ_NEED_BUFFER", TRACE_RDMA_REQUEST_STATE_NEED_BUFFER,
-	spdk_trace_register_description("NEW_RDMA_REQ_NAME", "",
-					NEW_TRACE_POINT_NAME,
 					OWNER_NONE, OBJECT_NVMF_RDMA_IO, 0,
-					SPDK_TRACE_ARG_TYPE_PTR, "cmid:	");
+					SPDK_TRACE_ARG_TYPE_PTR, "qpair");
+	...
 }
 ~~~
 
@@ -236,16 +235,16 @@ record the current trace state of several tracepoints.
 
 ~~~c
 	case RDMA_REQUEST_STATE_NEW:
-		spdk_trace_record(TRACE_RDMA_REQUEST_STATE_NEW, 0, 0, (uintptr_t)rdma_req, (uintptr_t)rqpair->cm_id);
+		spdk_trace_record(TRACE_RDMA_REQUEST_STATE_NEW, 0, 0, (uintptr_t)rdma_req, (uintptr_t)rqpair);
 		...
 		break;
 	case RDMA_REQUEST_STATE_NEED_BUFFER:
-		spdk_trace_record(TRACE_RDMA_REQUEST_STATE_NEED_BUFFER, 0, 0, (uintptr_t)rdma_req, (uintptr_t)rqpair->cm_id);
+		spdk_trace_record(TRACE_RDMA_REQUEST_STATE_NEED_BUFFER, 0, 0, (uintptr_t)rdma_req, (uintptr_t)rqpair);
 		...
 		break;
-	case RDMA_REQUEST_STATE_TRANSFER_PENDING_HOST_TO_CONTROLLER:
+	case RDMA_REQUEST_STATE_DATA_TRANSFER_TO_CONTROLLER_PENDING:
-		spdk_trace_record(TRACE_RDMA_REQUEST_STATE_TRANSFER_PENDING_HOST_TO_CONTROLLER, 0, 0,
+		spdk_trace_record(RDMA_REQUEST_STATE_DATA_TRANSFER_TO_CONTROLLER_PENDING, 0, 0,
-			(uintptr_t)rdma_req, (uintptr_t)rqpair->cm_id);
+			(uintptr_t)rdma_req, (uintptr_t)rqpair);
 		...
 ~~~
 

doc/performance_reports.md

@@ -1,5 +1,38 @@
 # Performance Reports {#performance_reports}
 
+## Release 23.01
+
+- [SPDK 23.01 NVMe Bdev Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_perf_report_2301.pdf)
+- [SPDK 23.01 Vhost Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_vhost_perf_report_2301.pdf)
+- [SPDK 23.01 NVMe-oF TCP Performance Report (Mellanox ConnectX-5)](https://ci.spdk.io/download/performance-reports/SPDK_tcp_mlx_perf_report_2301.pdf)
+- [SPDK 23.01 NVMe-oF TCP Performance Report (Intel E810-CQDA2)](https://ci.spdk.io/download/performance-reports/SPDK_tcp_cvl_perf_report_2301.pdf)
+- [SPDK 23.01 NVMe-oF RDMA Performance Report (Mellanox ConnectX-5)](https://ci.spdk.io/download/performance-reports/SPDK_rdma_mlx_perf_report_2301.pdf)
+- [SPDK 23.01 NVMe-oF RDMA Performance Report (Intel E810-CQDA2 iWARP)](https://ci.spdk.io/download/performance-reports/SPDK_rdma_cvl_iwarp_perf_report_2301.pdf)
+- [SPDK 23.01 NVMe-oF RDMA Performance Report (Intel E810-CQDA2 RoCEv2)](https://ci.spdk.io/download/performance-reports/SPDK_rdma_cvl_roce_perf_report_2301.pdf)
+
+## Release 22.09
+
+- [SPDK 22.09 NVMe Bdev Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_perf_report_2209.pdf)
+- [SPDK 22.09 NVMe-oF TCP Performance Report (Mellanox ConnectX-5)](https://ci.spdk.io/download/performance-reports/SPDK_tcp_mlx_perf_report_2209.pdf)
+- [SPDK 22.09 NVMe-oF TCP Performance Report (Intel E810-CQDA2)](https://ci.spdk.io/download/performance-reports/SPDK_tcp_cvl_perf_report_2209.pdf)
+- [SPDK 22.09 NVMe-oF RDMA Performance Report (Mellanox ConnectX-5)](https://ci.spdk.io/download/performance-reports/SPDK_rdma_mlx_perf_report_2209.pdf)
+- [SPDK 22.09 Vhost Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_vhost_perf_report_2209.pdf)
+
+## Release 22.05
+
+- [SPDK 22.05 NVMe Bdev Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_perf_report_2205.pdf)
+- [SPDK 22.05 NVMe-oF TCP Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_tcp_perf_report_2205.pdf)
+- [SPDK 22.05 NVMe-oF RDMA Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_rdma_perf_report_2205.pdf)
+- [SPDK 22.05 Vhost Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_vhost_perf_report_2205.pdf)
+
+## Release 22.01
+
+- [SPDK 22.01 NVMe Bdev Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_perf_report_2201.pdf)
+- [SPDK 22.01 NVMe Bdev PCIe Gen4 Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_gen4_perf_report_2201.pdf)
+- [SPDK 22.01 NVMe-oF TCP Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_tcp_perf_report_2201.pdf)
+- [SPDK 22.01 NVMe-oF RDMA Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_rdma_perf_report_2201.pdf)
+- [SPDK 22.01 Vhost Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_vhost_perf_report_2201.pdf)
+
 ## Release 21.10
 
 - [SPDK 21.10 NVMe Bdev Performance Report](https://ci.spdk.io/download/performance-reports/SPDK_nvme_bdev_perf_report_2110.pdf)

doc/scheduler.md

@@ -48,28 +48,50 @@ core has to be managed by the administrator.
 ## Scheduler implementations
 
 The scheduler in use may be controlled by JSON-RPC. Please use the
-[framework_set_scheduler](jsonrpc.md/#rpc_framework_set_scheduler) RPC to
+[framework_set_scheduler](jsonrpc.html#rpc_framework_set_scheduler) RPC to
-switch between schedulers or change their options.
+switch between schedulers or change their options. Currently only dynamic
+scheduler supports changing its parameters.
 
-[spdk_top](spdk_top.md#spdk_top) is a useful tool to observe the behavior of
+[spdk_top](spdk_top.html#spdk_top) is a useful tool to observe the behavior of
 schedulers in different scenarios and workloads.
 
 ### static [default]
 
 The `static` scheduler is the default scheduler and does no dynamic scheduling.
 Lightweight threads are distributed round-robin among reactors, respecting
-their requested cpu_mask, and then they are never moved. This is equivalent to
+their requested cpu_mask, only at application startup, and then they are never
-the previous behavior of the SPDK event/application framework.
+moved. This is equivalent to the previous behavior of the SPDK event/application
+framework.
+
+The `static` scheduler cannot be re-enabled after a different scheduler has been
+selected, because currently there is no way to save original SPDK thread distribution
+configuration.
 
 ### dynamic
 
 The `dynamic` scheduler is designed for power saving and reduction of CPU
 utilization, especially in cases where workloads show large variations over
-time.
+time. In SPDK thread and core workloads are measured in CPU ticks. Those
+values are then compared with all the ticks since the last check, which allows
+to calculate `busy time`.
+
+`busy time = busy ticks / (busy tick + idle tick) * 100 %`
+
+The thread is considered to be active, if its busy time is over the `load limit`
+parameter.
 
 Active threads are distributed equally among reactors, taking cpu_mask into
 account. All idle threads are moved to the main core. Once an idle thread becomes
-active, it is redistributed again.
+active, it is redistributed again. Dynamic scheduler monitors core workloads and
+redistributes SPDK threads on cores in a way that none of them is over `core limit`.
+In case a core utilization surpasses this threshold, scheduler should move threads
+out of it until this condition no longer applies. Cores might also be in overloaded
+state, which indicates that moving threads out of this core will not decrease its
+utilization under the `core limit` and the threads are unable to process all the I/O
+they are capable of, because they share CPU ticks with other threads. The threshold
+to decide if a core is overloaded is called `core busy`. Note that threads residing
+on an overloaded core will not perform as good as other threads, because the CPU ticks
+intended for them are limited by other threads on the same core.
 
 When a reactor has no scheduled `spdk_thread`s it is switched into interrupt
 mode and stops actively polling. After enough threads become active, the
@@ -80,3 +102,9 @@ not exceed the sum of all idle threads. When no active threads are present on
 the main core, the frequency of that CPU core will decrease as the load
 decreases. All CPU cores corresponding to the other reactors remain at maximum
 frequency.
+
+The dynamic scheduler is currently the only one that allows manual setting of
+its parameters.
+
+Current values of scheduler parameters can be displayed by using
+[framework_get_scheduler](jsonrpc.html#rpc_framework_get_scheduler) RPC.

doc/sma.md

@@ -0,0 +1,181 @@
+# Storage Management Agent {#sma}
+
+Storage Management Agent (SMA) is a service providing a gRPC interface for
+orchestrating SPDK applications.  It's a standalone application that allows
+users to create and manage various types of devices (e.g. NVMe, virtio-blk,
+etc.).  The major difference between SMA's API and the existing SPDK-RPC
+interface is that it's designed to abstract the low level details exposed by
+SPDK-RPCs, which enables it to be more easily consumed by orchestration
+frameworks, such as k8s or OpenStack.  This is especially important for
+deployments on IPUs (Infrastructure Processing Unit), which usually require a
+lot of hardware-specific options.
+
+## Interface
+
+The interface is defined in a protobuf files located in `proto`
+directory.  The generic interface common to all types of devices is defined in
+`sma.proto` file, while device-specific options are defined in their separate
+files (e.g. `nvme.proto` for NVMe).
+
+Currently, the interface consists of four methods.  Additionally, it defines two
+main types of objects: volumes and devices.  A volume is a representation of
+some storage media.  It is equivalent to a SPDK bdev and/or an NVMe namespace
+and can exist even if it's not presented to the host system.  A device is
+usually a virtual/physical PCIe function that is exposed to a host.  It is
+capable of presenting one or more volumes (depending on the type of the device)
+to a host.
+
+The following sections provide a high-level description of each method.  For
+more details, consult the protobuf definitions.
+
+### CreateDevice
+
+This method creates a device.  If a device with given parameters already exists,
+it becomes a no-op and returns a handle to that device.
+
+Input:
+
+- `volume`: Volume parameters describing a volume to immediately attach to the
+  created device.  This field may be optional for some device types (e.g. NVMe),
+  while it may be required for others (e.g. virtio-blk). Extending parameters with
+  crypto attributes like encryption type, keys, tweak mode allows the user to configure
+  crypto when attaching a volume to a device. Users must specify the crypto engine
+  to use under `crypto` section in config. It is also possible to register out-of-tree
+  crypto engines by inheriting from the `CryptoEngine` class.
+- `params`: Device-specific parameters.  The type of this structure determines
+  the type of device to create.
+
+Output:
+
+- `handle`: Opaque handle identifying the device.
+
+### DeleteDevice
+
+This method deletes a device.  Volumes that are still attached to a device being
+deleted will be automatically detached.
+
+Input:
+
+- `handle`: Device handle obtained from `CreateDevice`.
+
+### AttachVolume
+
+This method creates a volume and attaches it to a device exposing it to the
+host.  It might lead to establishing a connection to remote storage target.
+However, this is not always the case, even if the volume is remote.  For
+instance, if a volume describes an NVMe namespace, it might already be connected
+if another volume on the same subsystem was created previously.  It may be
+unsupported by some types of devices (e.g. virtio-blk).
+
+Input:
+
+- `volume`: Parameters describing the volume to attach.  The type of this
+  structure determines the method to create it (e.g. direct NVMe-oF connection,
+  NVMe-oF through discovery service, iSCSI, etc.). Extending parameters with
+  crypto attributes like type, keys, tweak mode allowing the user to configure crypto
+  when attaching a volume to a device. Users must specify the crypto engine to use under
+  `crypto` section in config. It is also possible to register out-of-tree crypto engines
+  by inheriting from the `CryptoEngine` class.
+- `device_handle`: Device handle obtained from `CreateDevice`.
+
+### DetachVolume
+
+This method detaches a volume from a device making it unavailable to the host.
+It may be unsupported by some types of devices (e.g. virtio-blk).
+
+Input:
+
+- `volume_id`: Volume UUID/GUID.
+- `device_handle`: Device handle obtained from `CreateDevice`.
+
+### SetQos
+
+This method configures QoS on a per-device or per-volume level.
+Not all QoS settings have to be supported by each device, so users
+can use `GetQosCapabilities` to get capabilities.
+
+Input:
+
+- `handle`: Device handle obtained from `CreateDevice`.
+- `volume_id`: Volume UUID/GUID. If this parameter is omitted, the QoS will be set up
+  on the whole device (all volumes attached to that device will share QoS settings).
+  Some device types might only support configuring QoS on per-device
+  (volume_id must be empty) or per-volume level (volume_id cannot be empty).
+  This information can be obtained by sending a GetQosCapabilities request.
+- `maximum`: Maximum allowed IOPS/bandwidth values.
+
+### GetQosCapabilities
+
+This method queries supported QoS settings.
+
+Input:
+
+- `device_type`: Type of a device to query for QoS capabilities.
+
+Output:
+
+- `capabilities`: QoS capabilities response including device/volume
+   QoS limits like read IOPS, write IOPS, read/write IOPS, read bandwidth,
+   write bandwidth, read/write bandwidth.
+
+## Running and Configuration
+
+In order to run SMA, SPDK needs to be configured with the `--with-sma` flag.
+Then, SMA can be started using a script located in `scripts/sma.py`.  It
+requires a YAML configuration file that specifies which types of devices to
+service, as well as several other options (e.g. listen address, SPDK-RPC socket,
+etc.).  Device types not listed in the configuration will be disabled and it
+won't be possible to manage them.  Below is an example configuration enabling
+two device types (NVMe/vfiouser and vhost-blk):
+
+```yaml
+address: 'localhost'
+socket: '/var/tmp/spdk.sock'
+port: 8080
+devices:
+  - name: 'vfiouser'
+    params:
+      root_path: '/var/tmp/vfiouser'
+      bus: 'bus0'
+      address: '127.0.0.1'
+      port: 4444
+  - name: 'vhost-blk'
+```
+
+## Plugins
+
+SMA provides a way to load external plugins implementing support for specific
+device types.  A plugin will be loaded if it's specified in the `SMA_PLUGINS`
+environment variable (multiple plugins are separated with a colon) or if it's
+specified in the `plugins` section of the config file.  For example, the
+following two methods are equivalent:
+
+```sh
+$ SMA_PLUGINS=plugin1:plugin2 scripts/sma.py
+
+$ cat sma.yaml
+address: 'localhost'
+port: 8080
+plugins:
+  - 'plugin1'
+  - 'plugin2'
+devices:
+  - name: 'device-from-plugin1'
+  - name: 'device-from-plugin2'
+$ scripts/sma.py -c sma.yaml
+```
+
+Each plugin needs to be in the python search path (either in one of the default
+directories or added to `PYTHONPATH`).
+
+A plugin is required to define a global variable called `devices` storing a list
+of classes deriving from `spdk.sma.DeviceManager`.  This base class define the
+interface each device needs to implement.  Additionally, each DeviceManager
+needs to define a unique name that will be used to identify it in config file as
+well as the name of the protocol it supports.  There can be many DeviceManagers
+supporting the same protocol, but only one can be active at a time.  The name of
+the protocol shall match the type specified in `CreateDeviceRequest.params`
+(e.g. "nvme", "virtio_blk", etc.), as it'll be used to select the DeviceManager
+to handle a gRPC request.  Finally, a DeviceManager needs to implement the
+`own_device()` method returning a boolean value indicating whether a given
+device handle is owned by that DeviceManager.

doc/spdk_top.md

@@ -15,6 +15,10 @@ spdk_top utility gets the fine grained metrics from the pollers, analyzes and re
 This information enables users to identify CPU cores that are busy doing real work so that they can determine if the application
 needs more or less CPU resources.
 
+spdk_top uses RPCs to communicate with the app it is viewing, so it will work only with those that run RPC server and support
+`thread_get_stats`, `thread_get_pollers`, `framework_get_reactors` methods. Apps currently meeting this criteria:
+spdk_tgt, nvmf_tgt, vhost, iscsi_tgt.
+
 ## Run spdk_top
 
 Before running spdk_top you need to run the SPDK application whose performance you want to analyze using spdk_top.
@@ -83,4 +87,9 @@ window allows to select a thread and display thread details pop-up on top of it.
 
 ## Help Window
 
-Help window pop-up can be invoked by pressing H key inside any tab. It contains explanations for each key used inside the spdk_top application.
+Help window pop-up can be invoked by pressing 'h' key inside any tab. It contains explanations for each key used inside the spdk_top application.
+
+## Scheduler Pop-up
+
+Current scheduler information may be displayed with 'g' key inside all tabs. It contains scheduler name and period along with governor
+name.

doc/spdkcli.md

@@ -1,36 +1,38 @@
-# SPDK CLI {#spdkcli}
+# spdkcli {#spdkcli}
 
-Spdkcli is a command-line management application for SPDK.
+spdkcli is a command-line management application for SPDK.
-Spdkcli has support for a limited number of applications and bdev modules,
+spdkcli has support for most transport protocols and
-and should be considered experimental for the v18.04 release.
+bdev modules.
-This experimental version was added for v18.04 to get early feedback
-that can be incorporated as spdkcli becomes more fully-featured
-for the next SPDK release.
 
-## Install needed dependencies
+## Dependencies
 
-All dependencies should be handled by scripts/pkgdep.sh script.
+Dependencies are installed by scripts/pkgdep.sh.
 Package dependencies at the moment include:
 
 - configshell
 
-## Run SPDK application instance
+Some distributions name the package configshell_fb.
+
+## Example usage
+
+### Start SPDK application
 
 ~~~{.sh}
 ./scripts/setup.sh
 ./build/bin/vhost -c vhost.json
 ~~~
 
-## Run SPDK CLI
+### Run spdkcli
 
-Spdkcli should be run with the same privileges as SPDK application.
+spdkcli should be run with the same privileges as SPDK application.
-In order to use SPDK CLI in interactive mode please use:
+
+To use spdkcli in interactive mode:
 ~~~{.sh}
 scripts/spdkcli.py
 ~~~
 Use "help" command to get a list of available commands for each tree node.
 
-It is also possible to use SPDK CLI to run just a single command,
+It is also possible to use spdkcli to run just a single command,
 just use the command as an argument to the application.
 For example, to view current configuration and immediately exit:
 ~~~{.sh}

doc/ublk.md

@@ -0,0 +1,217 @@
+# ublk Target {#ublk}
+
+## Table of Contents {#ublk_toc}
+
+- @ref ublk_intro
+- @ref ublk_internal
+- @ref ublk_impl
+- @ref ublk_op
+
+## Introduction {#ublk_intro}
+
+[ublk](https://docs.kernel.org/block/ublk.html) (or ubd) is a generic framework for
+implementing generic userspace block device based on `io_uring`.  It is designed to
+create a highly efficient data path for userspace storage software to provide
+high-performance block device service in local host.
+
+The whole ublk service involves three parts: ublk driver, ublk server and ublk workload.
+
+![ublk service stack](img/ublk_service.svg)
+
+* __ublk driver__ is a kernel driver added to kernel 6.0.  It delivers I/O requests
+  from a ublk block device(`/dev/ublkbN`) into a ublk server.
+
+* __ublk workload__ can be any local host process which submits I/O requests to a ublk
+  block device or a kernel filesystem on top of the ublk block device.
+
+* __ublk server__ is the userspace storage software that fetches the I/O requests delivered
+  by the ublk driver.  The ublk server will process the I/O requests with its specific block
+  service logic and connected backends.  Once the ublk server gets the response from the
+  connected backends, it communicates with the ublk driver and completes the I/O requests.
+
+SPDK ublk target acts as a ublk server.  It can handle ublk I/O requests within the whole
+SPDK userspace storage software stack.
+
+A typical usage scenario is for container attached storage:
+
+* Real storage resources are assigned to SPDK, like physical NVMe devices and
+  distributed block storage.
+* SPDK creates refined block devices via ublk kernel module on top of its organized
+  storage resources, based on user configuration.
+* Container orchestrator and runtime can then mount and stage the ublk block devices
+  for container instances to use.
+
+## ublk Internal {#ublk_internal}
+
+Previously, the design of putting I/O processing logic into userspace software always has a
+noticeable interaction overhead between the kernel module and userspace part.
+
+ublk utilizes `io_uring` which has been proven to be very efficient in decreasing the
+interaction overhead.  The I/O request is delivered to the userspace ublk server via the
+newly added `io_uring` command.  A shared buffer via `mmap` is used for sharing I/O descriptor
+to userspace from the kernel driver.  The I/O data is copied only once between the specified
+userspace buffer address and request/bio's pages by the ublk driver.
+
+### Control Plane
+
+A control device is create by ublk kernel module at `/dev/ublk-control`.  Userspace server
+sends control commands to kernel module via the control device using `io_uring`.
+
+Control commands includes add, configure, and start new ublk block device.
+Retrieving device information, stop and delete existing ublk block device are also there.
+
+The add device command creates a bulk char device `/dev/ublkcN`.
+It will be used by the ublk userspace server to `mmap` I/O descriptor buffer.
+The start device command exposes a ublk block device `/dev/ublkbN`.
+The block device can be formatted and mounted by a kernel filesystem,
+or read/written directly by other processes.
+
+### Data Plane
+
+The datapath between ublk server and kernel driver includes `io_uring` and shared
+memory buffer.  The shared memory buffer is an array of I/O descriptors.
+Each SQE (Submission Queue Entry) in `io_uring` is assigned one I/O descriptor and
+one user buffer address.  When ublk kernel driver receives I/O requests from upper
+layer, the information of I/O requests will be filled into I/O descriptors by ublk
+kernel driver.  The I/O data is copied between the specified user buffer address and
+request/bio's pages at the proper time.
+
+At start, the ublk server needs to fill the `io_uring` SQ (Submission Queue).  Each
+SQE is marked with an operation flag `UBLK_IO_FETCH_REQ` which means the SQE is
+ready to get I/O request.
+
+When a CQE (Completion Queue Entry) is returned from the `io_uring` indicating I/O
+request, the ublk server gets the position of the I/O descriptor from CQE.
+The ublk server handles the I/O request based on information in the I/O descriptor.
+
+After the ublk server completes the I/O request, it updates the I/O's completion status
+and ublk operation flag.  This time, the operation flag is `UBLK_IO_COMMIT_AND_FETCH_REQ`
+which informs kernel module that one I/O request is completed, and also the SQE slot
+is free to fetch new I/O request.
+
+`UBLK_IO_COMMIT_AND_FETCH_REQ` is designed for efficiency in ublk. In runtime, the ublk
+server needs to commit I/O results back, and then provide new free SQE slots for fetching
+new I/O requests.  Without `UBLK_IO_COMMIT_AND_FETCH_REQ` flag, `io_uring_submit()` should
+be called twice,  once for committing I/O results back, once for providing free SQE slots.
+With `UBLK_IO_COMMIT_AND_FETCH_REQ` flag, calling `io_uring_submit()` once is enough because
+the ublk driver realizes that the submitted SQEs are reused both for committing back I/O
+results and fetching new requests.
+
+## SPDK Implementation {#ublk_impl}
+
+SPDK ublk target is implemented as a high performance ublk server.
+
+It creates one ublk spdk_thread on each spdk_reactor by default or on user specified
+reactors.  When adding a new ublk block device, SPDK ublk target will assign queues
+of ublk block device to ublk spdk_threads in round-robin.
+That means one ublk device queue will only be processed by one spdk_thread.
+One ublk device with multiple queues can get multiple spdk reactors involved
+to process its I/O requests;
+One spdk_thread created by ublk target may process multiple queues, each from
+different ublk devices.
+In this way, spdk reactors can be fully utilized to achieve best performance,
+when there are only a few ublk devices.
+
+ublk is `io_uring` based. All ublk I/O queues are mapped to `io_uring`.
+ublk spdk_thread gets I/O requests from available CQEs by polling all its assigned
+`io_uring`s.
+When there are completed I/O requests, ublk spdk_thread will submit them as SQE back
+to `io_uring` in batch.
+
+Currently, ublk driver has a system thread context limitation that one ublk device queue
+can be only processed in the context of system thread which initialized the it.  SPDK
+can't schedule ublk spdk_thread between different SPDK reactors.  In other words, SPDK
+dynamic scheduler can't rebalance ublk workload by rescheduling ublk spdk_thread.
+
+## Operation {#ublk_op}
+
+### Enabling SPDK ublk target
+
+Build SPDK with SPDK ublk target enabled.
+
+~~~{.sh}
+./configure --with-ublk
+make -j
+~~~
+
+SPDK ublk target related libaries will then be linked into SPDK appliation `spdk_tgt`.
+Setup some hugepages for the SPDK, and then run the SPDK application `spdk_tgt`.
+
+~~~{.sh}
+scripts/setup.sh
+build/bin/spdk_tgt &
+~~~
+
+Once the `spdk_tgt` is initialized, user can enable SPDK ublk feature
+by creating ublk target. However, before creating ublk target, ublk kernel module
+`ublk_drv` should be loaded using `modprobe`.
+
+~~~{.sh}
+modprobe ublk_drv
+scripts/rpc.py ublk_create_target
+~~~
+
+### Creating ublk block device
+
+SPDK bdevs are block devices which will be exposed to the local host kernel
+as ublk block devices.  SPDK supports several different types of storage backends,
+including NVMe, Linux AIO, malloc ramdisk and Ceph RBD.  Refer to @ref bdev for
+additional information on configuring SPDK storage backends.
+
+This guide will use a malloc bdev (ramdisk) named Malloc0. The following RPC
+will create a 256MB malloc bdev with 512-byte block size.
+
+~~~{.sh}
+scripts/rpc.py bdev_malloc_create 256 512 -b Malloc0
+~~~
+
+The following RPC will create a ublk block device exposing Malloc0 bdev.
+The created ublk block device has ID 1.  It internally has 2 queues with
+queue depth 128.
+
+~~~{.sh}
+scripts/rpc.py ublk_start_disk Malloc0 1 -q 2 -d 128
+~~~
+
+This RPC will reply back the ID of ublk block device.
+~~~
+1
+~~~
+
+The position of ublk block device is determined by its ID. It is created at `/dev/ublkb${ID}`.
+So the device we just created will be accessible to other processes via `/dev/ublkb1`.
+Now applications like FIO or DD can work on `/dev/ublkb1` directly.
+
+~~~{.sh}
+dd of=/dev/ublkb1 if=/dev/zero bs=512 count=64
+~~~
+
+A ublk block device is a generic kernel block device that can be formatted and
+mounted by kernel file system.
+
+~~~{.sh}
+mkfs /dev/ublkb1
+mount /dev/ublkb1 /mnt/
+mkdir /mnt/testdir
+echo "Hello，SPDK ublk Target" > /mnt/testdir/testfile
+umount /mnt
+~~~
+
+### Deleting ublk block device and exit
+
+After usage, ublk block device can be stopped and deleted by RPC `ublk_stop_disk` with its ID.
+Specify ID 1, then device `/dev/ublkb1` will be removed.
+
+~~~{.sh}
+scripts/rpc.py ublk_stop_disk 1
+~~~
+
+If ublk is not used anymore, SPDK ublk target can be destroyed to free related SPDK
+resources.
+
+~~~{.sh}
+scripts/rpc.py ublk_destroy_target
+~~~
+
+Of course, SPDK ublk target and all ublk block devices would be destroyed automatically
+when SPDK application is terminated.

doc/usdt.md

@@ -1,41 +1,10 @@
 # Userspace DTrace (USDT) {#usdt}
 
-## Package Dependencies
-
-These dependencies are needed for building bpftrace and
-the sys/sdt.h header file that SPDK libraries will include
-for DTRACE_PROBE macro definitions.
-
-Fedora:
-libbpf
-gtest-devel
-gmock-devel
-bcc-devel
-systemtap-sdt-devel
-llvm-devel
-bison
-flex
-
-Ubuntu:
-systemtap-sdt-dev
-libbpfcc-dev
-libclang-7-dev
-bison
-flex
-
 ## Building bpftrace
 
 We have found issues with the packaged bpftrace on both Ubuntu 20.04
 and Fedora 33.  So bpftrace should be built and installed from source.
-
+To build and install bpftrace go to [building bpftraces](https://github.com/iovisor/bpftrace/blob/master/INSTALL.md#building-bpftrace)
-```bash
-git clone https://github.com/iovisor/bpftrace.git
-mkdir bpftrace/build
-cd bpftrace/build
-cmake -DCMAKE_BUILD_TYPE=Release ..
-make
-sudo make install
-```
 
 ## bpftrace.sh
 

doc/user_guides.md

@@ -12,3 +12,6 @@
 - @subpage jsonrpc
 - @subpage jsonrpc_proxy
 - @subpage usdt
+- @subpage nvme_multipath
+- @subpage sma
+- @subpage ublk

doc/vagrant.md

@@ -116,7 +116,7 @@ Bringing machine 'default' up with 'virtualbox' provider...
   Use vagrant "destroy" followed by "rm -rf ubuntu18" to destroy all trace of vm.
 ~~~
 
-Check the enviroment.
+Check the environment.
 
 ~~~{.sh}
 user@dev-system:~/spdk/scripts/vagrant$ cd ubuntu18

doc/vhost.md

@@ -231,7 +231,7 @@ EAL:   using IOMMU type 1 (Type 1)
 ~~~
 
 ~~~{.sh}
-host:~# ./scripts/rpc.py bdev_malloc_create 128 4096 Malloc0
+host:~# ./scripts/rpc.py bdev_malloc_create 128 4096 -b Malloc0
 Malloc0
 ~~~
 

doc/vhost_processing.md

@@ -42,7 +42,7 @@ The initial vhost implementation is a part of the Linux kernel and uses ioctl
 interface to communicate with userspace applications. What makes it possible for
 SPDK to expose a vhost device is Vhost-user protocol.
 
-The [Vhost-user specification](https://git.qemu.org/?p=qemu.git;a=blob_plain;f=docs/interop/vhost-user.txt;hb=HEAD)
+The [Vhost-user specification](https://qemu-project.gitlab.io/qemu/interop/vhost-user.html)
 describes the protocol as follows:
 
 > [Vhost-user protocol] is aiming to complement the ioctl interface used to
@@ -51,17 +51,19 @@ describes the protocol as follows:
 > same host. It uses communication over a Unix domain socket to share file
 > descriptors in the ancillary data of the message.
 >
-> The protocol defines 2 sides of the communication, master and slave. Master is
+> The protocol defines 2 sides of the communication, front-end and back-end.
-> the application that shares its virtqueues, in our case QEMU. Slave is the
+> The front-end is the application that shares its virtqueues, in our case QEMU.
-> consumer of the virtqueues.
+> The back-end is the consumer of the virtqueues.
 >
-> In the current implementation QEMU is the Master, and the Slave is intended to
+> In the current implementation QEMU is the front-end, and the back-end is
-> be a software Ethernet switch running in user space, such as Snabbswitch.
+> the external process consuming the virtio queues, for example a software
+> Ethernet switch running in user space, such as Snabbswitch, or a block
+> device back-end processing read and write to a virtual disk.
 >
-> Master and slave can be either a client (i.e. connecting) or server (listening)
+> The front-end and back-end can be either a client (i.e. connecting) or
-> in the socket communication.
+> server (listening) in the socket communication.
 
-SPDK vhost is a Vhost-user slave server. It exposes Unix domain sockets and
+SPDK vhost is a Vhost-user back-end server. It exposes Unix domain sockets and
 allows external applications to connect.
 
 ## QEMU {#vhost_processing_qemu}
@@ -76,7 +78,7 @@ communicates with SPDK Vhost-SCSI device.
 
 All initialization and management information is exchanged using Vhost-user
 messages. The connection always starts with the feature negotiation. Both
-the Master and the Slave exposes a list of their implemented features and
+the front-end and the back-end expose a list of their implemented features and
 upon negotiation they choose a common set of those. Most of these features are
 implementation-related, but also regard e.g. multiqueue support or live migration.
 
@@ -94,7 +96,7 @@ the following data:
 - user offset - positive offset for the mmap
 - size
 
-The Master will send new memory regions after each memory change - usually
+The front-end will send new memory regions after each memory change - usually
 hotplug/hotremove. The previous mappings will be removed.
 
 Drivers may also request a device config, consisting of e.g. disk geometry.
@@ -116,7 +118,7 @@ polled as soon as they're initialized.
 
 ## I/O path {#vhost_processing_io_path}
 
-The Master sends I/O by allocating proper buffers in shared memory, filling
+The front-end sends I/O by allocating proper buffers in shared memory, filling
 the request data, and putting guest addresses of those buffers into virtqueues.
 
 A Virtio-Block request looks as follows.

doc/vmd.md

@@ -85,7 +85,7 @@ JSON config:
     "subsystem": "vmd",
     "config": [
       {
-        "method": "enable_vmd",
+        "method": "vmd_enable",
         "params": {}
       }
     ]
@@ -95,7 +95,7 @@ JSON config:
 or use RPC call before framework starts e.g.
 ```
 $ ./build/bin/spdk_tgt --wait_for_rpc
-$ ./scripts/rpc.py enable_vmd
+$ ./scripts/rpc.py vmd_enable
 $ ./scripts/rpc.py framework_start_init
 ```
 ## Applications w/o application framework {#vmd_app}

docker/README.md

@@ -39,7 +39,7 @@ Running `docker-compose build` creates 5 docker images:
 - traffic-generator-virtio
 
 The `build_base` image provides the core components required to containerize SPDK
-applications. The fedora:33 image from the Fedora Container Registry is used and then SPDK is installed. SPDK is installed out of `build_base/spdk.tar.gz` provided.
+applications. The fedora:35 image from the Fedora Container Registry is used and then SPDK is installed. SPDK is installed out of `build_base/spdk.tar.gz` provided.
 See `build_base` folder for details on what's included in the final image.
 
 Running `docker-compose up` creates 3 docker containers:
@@ -75,7 +75,7 @@ docker-compose run traffic-generator-nvme
 docker-compose run traffic-generator-virtio
 ~~~
 
-Enviroment variables to containers can be passed as shown in
+Environment variables to containers can be passed as shown in
 [docs](https://docs.docker.com/compose/environment-variables/).
 For example extra arguments to fio can be passed as so:
 

docker/build_base/Dockerfile

@@ -1,7 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0
-# Copyright (c) Intel Corporation
+# Copyright (C) 2021 Intel Corporation
+#
 
-FROM fedora:33 AS base
+FROM fedora:35 AS base
+
+ARG spdk_repo=/tmp/spdk_repo
+ARG spdk_tar=/spdk.tar.gz
 
 # Generic args
 ARG PROXY
@@ -11,16 +15,38 @@ ENV http_proxy=$PROXY
 ENV https_proxy=$PROXY
 ENV no_proxy=$NO_PROXY
 
+COPY --chown=root:root spdk.tar.gz /spdk.tar.gz
+RUN if [[ ! -e $spdk_tar ]]; then printf 'Missing %s\n' "$spdk_tar" >&2; exit 1; fi
+RUN mkdir -p "$spdk_repo" && \
+	tar -C "$spdk_repo" -xf "$spdk_tar" && \
+	chown -R root:root "$spdk_repo"
+RUN dnf install -y rpm-build
+RUN "$spdk_repo/scripts/pkgdep.sh" -d
+RUN "$spdk_repo/test/common/config/vm_setup.sh" --test-conf=fio
 
-COPY spdk.tar.gz /spdk.tar.gz
+# HACK: In case we received a .tar with built SPDK we need to overwrite the
-COPY pre-install /install
+# configuration to update all the paths make would need to lookup - this is
-RUN /install
+# needed since we execute inside a different mount namespace so we won't be
+# able to find any absolute paths that were used prior creating the .tar.
+RUN "$spdk_repo/configure"
+RUN DEPS="no" "$spdk_repo/rpmbuild/rpm.sh" \
+	--with-shared \
+	--with-virtio \
+	--with-fio
+RUN mv "$HOME/rpmbuild/rpm/$(uname -m)/"*.rpm /tmp
+RUN mv "/usr/src/fio/fio" /tmp
+
+# Clean things up
+RUN rm -f "$HOME/rpmbuild/rpm/$(uname -m)/"*.rpm
+RUN rm -f "$spdk_tar"
+RUN rm -rf "$spdk_repo"
+RUN dnf clean all
 
 # We are doing a multi-stage build here. This means that previous image,
 # base, is going to end up as an intermediate one, untagged, <none> - this
 # image can be then manually removed (--force-rm doesn't work here. Go
 # figure).
-FROM fedora:33 AS spdk
+FROM fedora:35 AS spdk
 
 LABEL maintainer=spdk.io
 

docker/build_base/post-install

@@ -1,4 +1,9 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2021 Intel Corporation
+#  All rights reserved.
+#
+
 set -e
 
 dnf install -y /tmp/*.rpm

docker/build_base/pre-install

@@ -1,44 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-spdk_repo=$(mktemp -dt "spdk.XXXXXX")
-spdk_tar=/spdk.tar.gz
-
-cleanup() {
-
-	rm -f "$HOME/rpmbuild/rpm/x86_64/"*.rpm
-	rm -f "$spdk_tar"
-	rm -rf "$spdk_repo"
-}
-
-trap 'cleanup' EXIT
-
-if [[ ! -e $spdk_tar ]]; then
-	printf 'Missing %s\n' "$spdk_tar" >&2
-	exit 1
-fi
-
-tar -C "$spdk_repo" -xf "$spdk_tar"
-
-# Required for building RPM
-dnf install -y rpm-build
-
-# Spice it a bit with supported sources
-"$spdk_repo/scripts/pkgdep.sh" -d
-"$spdk_repo/test/common/config/vm_setup.sh" --test-conf=fio
-
-# HACK: In case we received a .tar with built SPDK we need to overwrite the
-# configuration to update all the paths make would need to lookup - this is
-# needed since we execute inside a different mount namespace so we won't be
-# able to find any absolute paths that were used prior creating the .tar.
-"$spdk_repo/configure" > /dev/null
-
-# Deploy SPDK inside the container
-DEPS="no" "$spdk_repo/rpmbuild/rpm.sh" \
-	--with-shared \
-	--with-virtio \
-	--with-fio
-
-mv "$HOME/rpmbuild/rpm/x86_64/"*.rpm /tmp
-mv "/usr/src/fio/fio" /tmp
-dnf clean all

docker/docker-compose.yaml

@@ -1,5 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0
-# Copyright (c) Intel Corporation
+# Copyright (C) 2021 Intel Corporation
+#
+
 version: "3.8"
 services:
   build_base:

docker/spdk-app/Dockerfile

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
-# Copyright (c) Intel Corporation
+# Copyright (C) 2021 Intel Corporation
+#
 
 FROM spdk
 

docker/spdk-app/init

@@ -1,4 +1,8 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2021 Intel Corporation
+#  All rights reserved.
+#
 
 app=spdk_tgt args=() limit_args=()
 

docker/traffic-generator/Dockerfile

@@ -1,5 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0
-# Copyright (c) Intel Corporation
+# Copyright (C) 2021 Intel Corporation
+#
 
 FROM spdk
 

docker/traffic-generator/init

@@ -1,4 +1,8 @@
 #!/usr/bin/env bash
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2021 Intel Corporation
+#  All rights reserved.
+#
 
 args=()
 

dpdk

@@ -1 +1 @@
-Subproject commit e981f07a3b01b99c9efddd4ae5cce764a677dba7
+Subproject commit 6fb6205c214b81af08d6e82d1c634f1a5cb1a8bb

dpdkbuild/Makefile

@@ -1,36 +1,8 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2017 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  All rights reserved.
 #  Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. 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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
@@ -51,6 +23,13 @@ ifeq ($(CONFIG_DEBUG),y)
 DPDK_OPTS += --buildtype=debug
 endif
 
+ifeq ($(CONFIG_LTO),y)
+# dpdk complains about compiler not supporting fat LTO objects when clang is in use so don't enable it in such a instance
+ifneq ($(CC_TYPE),clang)
+DPDK_OPTS += -Db_lto=true
+endif
+endif
+
 # the drivers we use
 DPDK_DRIVERS = bus bus/pci bus/vdev mempool/ring
 
@@ -60,40 +39,58 @@ DPDK_LIBS += kvargs telemetry
 # Governor required libs
 DPDK_LIBS += power timer ethdev net
 
-# common crypto/reduce drivers
+# common crypto/compress drivers
-ifeq ($(findstring y,$(CONFIG_CRYPTO)$(CONFIG_REDUCE)),y)
+ifeq ($(findstring y,$(CONFIG_DPDK_COMPRESSDEV)$(CONFIG_CRYPTO)$(CONFIG_VBDEV_COMPRESS)),y)
 DPDK_DRIVERS += crypto/qat compress/qat common/qat
 endif
 
-ifeq ($(CONFIG_CRYPTO),y)
+# common mlx5 libs
-DPDK_DRIVERS += crypto crypto/ipsec_mb
+ifeq ($(findstring y,$(CONFIG_CRYPTO_MLX5)$(CONFIG_VBDEV_COMPRESS_MLX5)),y)
-# aesni_mb is name of the PMD in DPDK 21.08 and earlier
+DPDK_DRIVERS += common/mlx5 bus/auxiliary
-DPDK_DRIVERS += crypto/aesni_mb
-DPDK_CFLAGS += -I$(IPSEC_MB_DIR)
-DPDK_LDFLAGS += -L$(IPSEC_MB_DIR)
 endif
 
-ifeq ($(CONFIG_REDUCE),y)
+ifeq ($(CONFIG_CRYPTO),y)
+DPDK_DRIVERS += crypto
+# aesni_mb is name of the PMD in DPDK 21.08 and earlier
+DPDK_DRIVERS += crypto/aesni_mb
+ifeq ($(CONFIG_CRYPTO_MLX5),y)
+DPDK_DRIVERS += crypto/mlx5
+endif
+ifeq ($(CONFIG_IPSEC_MB),y)
+DPDK_DRIVERS += crypto/ipsec_mb
+DPDK_CFLAGS += -I$(IPSEC_MB_DIR)
+# Workaround for DPDK 22.07 and DPDK 22.11.1,
+# will be able to remove starting with DPDK 23.03.
+ifeq ($(shell grep "define NO_COMPAT_IMB_API_053" $(SPDK_ROOT_DIR)/dpdk/drivers/crypto/qat/qat_sym_session.c), )
+DPDK_CFLAGS += -DNO_COMPAT_IMB_API_053
+endif
+DPDK_LDFLAGS += -L$(IPSEC_MB_DIR)
+endif
+endif
+
+ifeq ($(findstring y,$(CONFIG_DPDK_COMPRESSDEV)$(CONFIG_VBDEV_COMPRESS)),y)
 DPDK_DRIVERS += compress compress/isal
-ifeq ($(CONFIG_REDUCE_MLX5),y)
+ifeq ($(CONFIG_VBDEV_COMPRESS_MLX5),y)
-DPDK_DRIVERS += common/mlx5 compress/mlx5 bus/auxiliary
+DPDK_DRIVERS += compress/mlx5
 endif
 DPDK_CFLAGS += -I$(ISAL_DIR)
 DPDK_LDFLAGS += -L$(ISAL_DIR)/.libs -lisal
 endif
 
+DPDK_ENABLED_DRIVERS = $(shell echo $(DPDK_DRIVERS) | sed -E "s/ +/,/g")
+
 # crypto & compress deps
 DPDK_LIBS += reorder cryptodev
 DPDK_LIBS += compressdev
 DPDK_LIBS += security
 
 # vhost and deps
-DPDK_LIBS += cryptodev mbuf cmdline meter hash vhost
+DPDK_LIBS += cryptodev mbuf cmdline meter hash vhost dmadev
 
 # raid5 deps
 DPDK_LIBS += hash rcu
 
-DPDK_OPTS += -Dmachine=$(TARGET_ARCHITECTURE)
+DPDK_OPTS += -Dcpu_instruction_set=$(TARGET_ARCHITECTURE)
 
 ifneq ($(CONFIG_CROSS_PREFIX),)
 ifeq ($(findstring mingw,$(CONFIG_CROSS_PREFIX)),mingw)
@@ -106,6 +103,10 @@ endif
 
 DPDK_CFLAGS += -fPIC
 
+ifneq ($(CONFIG_MAX_LCORES),)
+DPDK_OPTS += -Dmax_lcores=$(CONFIG_MAX_LCORES)
+endif
+
 ifeq ($(CONFIG_WERROR),y)
 DPDK_CFLAGS += -Werror
 else
@@ -134,6 +135,14 @@ ifeq ($(shell test $(GCC_MAJOR) -ge 10 && echo 1), 1)
 #aesni_mb_logtype_driver symbol which is defined in header file and presented in several
 #translation units
 DPDK_CFLAGS += -Wno-stringop-overflow -fcommon
+ifeq ($(shell test $(GCC_MAJOR) -ge 12 && echo 1), 1)
+# 3. gcc 12 reports reading incorect size from a region. Seems like false positive,
+# see issue #2460
+DPDK_CFLAGS += -Wno-stringop-overread
+# 4. gcc 12 reports array subscript * is outside array bounds. Seems like false positive,
+# see issue #2668
+DPDK_CFLAGS += -Wno-array-bounds
+endif
 endif
 endif
 
@@ -142,7 +151,13 @@ SUB_CC = $(patsubst %ccc-analyzer,$(DEFAULT_CC),$(CC))
 
 DPDK_ALL_LIB_DIRS = $(shell find $(SPDK_ROOT_DIR)/dpdk/lib -mindepth 1 -maxdepth 1 -type d)
 DPDK_ALL_LIBS = $(DPDK_ALL_LIB_DIRS:$(SPDK_ROOT_DIR)/dpdk/lib/%=%)
-DPDK_DISABLED_LIBS = $(filter-out $(DPDK_LIBS),$(DPDK_ALL_LIBS))
+DPDK_DISABLED_LIBS = $(shell echo $(filter-out $(DPDK_LIBS),$(DPDK_ALL_LIBS)) | sed -E "s/ +/,/g")
+
+ifeq ($(shell grep -q disable_apps $(SPDK_ROOT_DIR)/dpdk/meson_options.txt && echo 1), 1)
+DPDK_ALL_APP_DIRS = $(shell find $(SPDK_ROOT_DIR)/dpdk/app -mindepth 1 -maxdepth 1 -type d)
+DPDK_ALL_APPS = $(DPDK_ALL_APP_DIRS:$(SPDK_ROOT_DIR)/dpdk/app/%=%)
+DPDK_DISABLED_APPS = -Ddisable_apps="$(shell echo $(DPDK_ALL_APPS) | sed -E "s/ +/,/g")"
+endif
 
 ifneq ($(OS),FreeBSD)
 SED_INPLACE_FLAG = "-i"
@@ -184,15 +199,8 @@ all: $(SPDK_ROOT_DIR)/dpdk/build-tmp
 
 $(SPDK_ROOT_DIR)/dpdk/build-tmp: $(SPDK_ROOT_DIR)/mk/cc.mk $(SPDK_ROOT_DIR)/include/spdk/config.h
 	$(Q)rm -rf $(SPDK_ROOT_DIR)/dpdk/build $(SPDK_ROOT_DIR)/dpdk/build-tmp
-	$(Q)cd "$(SPDK_ROOT_DIR)/dpdk"; CC="$(SUB_CC)" meson --prefix="$(MESON_PREFIX)" --libdir lib -Dc_args="$(DPDK_CFLAGS)" -Dc_link_args="$(DPDK_LDFLAGS)" $(DPDK_OPTS) -Denable_drivers="$(shell echo $(DPDK_DRIVERS) | sed -E "s/ +/,/g")" -Ddisable_libs="$(shell echo $(DPDK_DISABLED_LIBS) | sed -E "s/ +/,/g")" build-tmp
+	$(Q)cd "$(SPDK_ROOT_DIR)/dpdk"; CC="$(SUB_CC)" meson setup --prefix="$(MESON_PREFIX)" --libdir lib -Dc_args="$(DPDK_CFLAGS)" -Dc_link_args="$(DPDK_LDFLAGS)" $(DPDK_OPTS) -Denable_drivers="$(DPDK_ENABLED_DRIVERS)" -Ddisable_libs="$(DPDK_DISABLED_LIBS)" $(DPDK_DISABLED_APPS) $(DPDKBUILD_FLAGS) build-tmp
 	$(Q)sed $(SED_INPLACE_FLAG) 's/#define RTE_EAL_PMD_PATH .*/#define RTE_EAL_PMD_PATH ""/g' $(SPDK_ROOT_DIR)/dpdk/build-tmp/rte_build_config.h
-	$(Q) \
-	# TODO Meson build adds libbsd dependency when it's available. This means any app will be \
-	# forced to link with -lbsd, but only if it's available on the system. The clean way to \
-	# handle this would be to rely on DPDK's pkg-config file which will contain the -lbsd when \
-	# required. For now just remove the libbsd dependency. DPDK will fallback to its internal \
-	# functions.
-	$(Q)sed $(SED_INPLACE_FLAG) 's/#define RTE_USE_LIBBSD .*//g' $(SPDK_ROOT_DIR)/dpdk/build-tmp/rte_build_config.h
 
 clean:
 	$(Q)rm -rf $(SPDK_ROOT_DIR)/dpdk/build $(SPDK_ROOT_DIR)/dpdk/build-tmp

examples/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

examples/accel/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

examples/accel/perf/Makefile

@@ -1,35 +1,7 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2017 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

examples/bdev/Makefile

@@ -1,41 +1,13 @@
-#
+#  SPDX-License-Identifier: BSD-3-Clause
-#  BSD LICENSE
+#  Copyright (C) 2015 Intel Corporation.
-#
-#  Copyright (c) Intel Corporation.
 #  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.
-#
 
 SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..)
 include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
 
 DIRS-$(CONFIG_FIO_PLUGIN) = fio_plugin
-DIRS-y += hello_world
+DIRS-y += hello_world bdevperf
 
 .PHONY: all clean $(DIRS-y)
 

examples/bdev/bdevperf/Makefile

@@ -0,0 +1,24 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2016 Intel Corporation.
+#  All rights reserved.
+#
+
+SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
+include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
+include $(SPDK_ROOT_DIR)/mk/spdk.modules.mk
+
+APP = bdevperf
+
+C_SRCS := bdevperf.c
+
+SPDK_LIB_LIST = $(ALL_MODULES_LIST) event event_bdev conf
+
+ifeq ($(OS),Linux)
+SPDK_LIB_LIST += event_nbd
+endif
+
+ifeq ($(SPDK_ROOT_DIR)/lib/env_dpdk,$(CONFIG_ENV))
+SPDK_LIB_LIST += env_dpdk_rpc
+endif
+
+include $(SPDK_ROOT_DIR)/mk/spdk.app.mk