ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

bdev/pmem: Removed bdev pmem implementation

Browse Source 
Removed bdev pmem implementation and makefiles
Removed bdev pmem rpc calls
Updated Python scripts
Updated match files for tests
Updated doc files
pkgdep and doc files will be updated when pmem
dependency is removed from libreduce

Change-Id: Ia1be5046159e04cd933ac13a0d5791e6d28219da
Signed-off-by: Marcin Spiewak <marcin.spiewak@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/17070
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Community-CI: Mellanox Build Bot
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
This commit is contained in:
Marcin Spiewak 2023-03-06 16:25:42 +00:00 committed by Tomasz Zawadzki
parent 8da5783b52
commit b42295dbc3
27 changed files with 2 additions and 1249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CONFIG
View File

@ -126,10 +126,6 @@ CONFIG_VIRTIO=y
CONFIG_VFIO_USER=n
CONFIG_VFIO_USER_DIR=
# Build with PMDK backends
CONFIG_PMDK=n
CONFIG_PMDK_DIR=
# Build with xNVMe
CONFIG_XNVME=n

26
configure vendored
View File

@ -71,9 +71,6 @@ function usage() {
echo " vfio-user initiator is always built-in in Linux."
echo " example: /usr/src/libvfio-user"
echo " --without-vfio-user No path required."
echo " --with-pmdk[=DIR] Build persistent memory bdev. (Deprecated)
example: /usr/share/pmdk"
echo " --without-pmdk No path required."
echo " --with-vbdev-compress Build vbdev compression module and dependencies."
echo " --without-vbdev-compress No path required."
echo " --with-dpdk-compressdev Build accel DPDK compression module and dependencies."
@ -527,18 +524,6 @@ for i in "$@"; do
--without-vfio-user)
CONFIG[VFIO_USER]=n
;;
--with-pmdk)
CONFIG[PMDK]=y
CONFIG[PMDK_DIR]=""
;;
--with-pmdk=*)
CONFIG[PMDK]=y
check_dir "$i"
CONFIG[PMDK_DIR]=$(readlink -f ${i#*=})
;;
--without-pmdk)
CONFIG[PMDK]=n
;;
--with-vbdev-compress)
CONFIG[VBDEV_COMPRESS]=y
;;
@ -906,17 +891,6 @@ if [[ "${CONFIG[FC]}" = "y" ]]; then
fi
fi
if [[ "${CONFIG[PMDK]}" = "y" ]]; then
echo "WARNING: PMDK - bdev_pmem is deprecated."
echo "WARNING: PMDK - ACCEL_FLAG_PERSISTENT in accel_sw module is deprecated."
if ! echo -e '#include <libpmemblk.h>\nint main(void) { return 0; }\n' \
| "${BUILD_CMD[@]}" -lpmemblk - 2> /dev/null; then
echo "--with-pmdk requires libpmemblk."
echo "Please install then re-run this script."
exit 1
fi
fi
function dpdk_version() {
# Check DPDK version to determine if mlx5_pci driver is supported
local dpdk_ver="none"

4
deprecation.md
View File

@ -24,10 +24,6 @@ The tags can be matched with the level 4 headers below.
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/).
#### `bdev_pmem`
Deprecated `bdev_pmem` based on libpmemblk, it will be removed in SPDK 23.05.
#### `libreduce_pm_file`
Reduce library will no longer depend on libpmem. `pm_file_dir` parameter in `spdk_reduce_vol_init()`

37
doc/bdev.md
View File

@ -533,43 +533,6 @@ 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

218
doc/jsonrpc.md
View File

@ -5831,224 +5831,6 @@ Example response:
}
}
~~~
### bdev_pmem_create_pool {#rpc_bdev_pmem_create_pool}
Create a @ref bdev_config_pmem blk pool file. It is equivalent of following `pmempool create` command:
~~~bash
pmempool create -s $((num_blocks * block_size)) blk $block_size $pmem_file
~~~
This method is available only if SPDK was built with PMDK support.
#### Parameters
Name | Optional | Type | Description
----------------------- | -------- | ----------- | -----------
pmem_file | Required | string | Path to new pmem file
num_blocks | Required | number | Number of blocks
block_size | Required | number | Size of each block in bytes
#### Example
Example request:
~~~json
{
"params": {
"block_size": 512,
"num_blocks": 131072,
"pmem_file": "/tmp/pmem_file"
},
"jsonrpc": "2.0",
"method": "bdev_pmem_create_pool",
"id": 1
}
~~~
Example response:
~~~json
{
"jsonrpc": "2.0",
"id": 1,
"result": true
}
~~~
### bdev_pmem_get_pool_info {#rpc_bdev_pmem_get_pool_info}
Retrieve basic information about PMDK memory pool.
This method is available only if SPDK was built with PMDK support.
#### Parameters
Name | Optional | Type | Description
----------------------- | -------- | ----------- | -----------
pmem_file | Required | string | Path to existing pmem file
#### Result
Array of objects describing memory pool:
Name | Type | Description
----------------------- | ----------- | -----------
num_blocks | number | Number of blocks
block_size | number | Size of each block in bytes
#### Example
Example request:
~~~json
request:
{
"params": {
"pmem_file": "/tmp/pmem_file"
},
"jsonrpc": "2.0",
"method": "bdev_pmem_get_pool_info",
"id": 1
}
~~~
Example response:
~~~json
{
"jsonrpc": "2.0",
"id": 1,
"result": [
{
"block_size": 512,
"num_blocks": 129728
}
]
}
~~~
### bdev_pmem_delete_pool {#rpc_bdev_pmem_delete_pool}
Delete pmem pool by removing file `pmem_file`. This method will fail if `pmem_file` is not a
valid pmem pool file.
This method is available only if SPDK was built with PMDK support.
#### Parameters
Name | Optional | Type | Description
----------------------- | -------- | ----------- | -----------
pmem_file | Required | string | Path to new pmem file
#### Example
Example request:
~~~json
{
"params": {
"pmem_file": "/tmp/pmem_file"
},
"jsonrpc": "2.0",
"method": "bdev_pmem_delete_pool",
"id": 1
}
~~~
Example response:
~~~json
{
"jsonrpc": "2.0",
"id": 1,
"result": true
}
~~~
### bdev_pmem_create {#rpc_bdev_pmem_create}
Construct @ref bdev_config_pmem bdev.
This method is available only if SPDK was built with PMDK support.
#### Parameters
Name | Optional | Type | Description
----------------------- | -------- | ----------- | -----------
name | Required | string | Bdev name
pmem_file | Required | string | Path to existing pmem blk pool file
#### Result
Name of newly created bdev.
#### Example
Example request:
~~~json
{
"params": {
"pmem_file": "/tmp/pmem_file",
"name": "Pmem0"
},
"jsonrpc": "2.0",
"method": "bdev_pmem_create",
"id": 1
}
~~~
Example response:
~~~json
{
"jsonrpc": "2.0",
"id": 1,
"result": "Pmem0"
}
~~~
### bdev_pmem_delete {#rpc_bdev_pmem_delete}
Delete @ref bdev_config_pmem bdev. This call will not remove backing pool files.
This method is available only if SPDK was built with PMDK support.
#### Result
`true` if bdev with provided name was deleted or `false` otherwise.
#### Parameters
Name | Optional | Type | Description
----------------------- | -------- | ----------- | -----------
name | Required | string | Bdev name
#### Example
Example request:
~~~json
{
"params": {
"name": "Pmem0"
},
"jsonrpc": "2.0",
"method": "bdev_pmem_delete",
"id": 1
}
~~~
Example response:
~~~json
{
"jsonrpc": "2.0",
"id": 1,
"result": true
}
~~~
### bdev_passthru_create {#rpc_bdev_passthru_create}

6
mk/spdk.common.mk
View File

@ -158,12 +158,6 @@ SYS_LIBS += -L/usr/local/lib
COMMON_CFLAGS += -I/usr/local/include
endif
# Attach only if PMDK lib specified with configure
ifneq ($(CONFIG_PMDK_DIR),)
LIBS += -L$(CONFIG_PMDK_DIR)/src/nondebug
COMMON_CFLAGS += -I$(CONFIG_PMDK_DIR)/src/include
endif
ifeq ($(CONFIG_RDMA),y)
SYS_LIBS += -libverbs -lrdmacm
endif

1
mk/spdk.lib_deps.mk
View File

@ -145,7 +145,6 @@ DEPDIRS-bdev_null := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_nvme = $(BDEV_DEPS_THREAD) accel nvme trace
DEPDIRS-bdev_ocf := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_passthru := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_pmem := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_raid := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_rbd := $(BDEV_DEPS_THREAD)
DEPDIRS-bdev_uring := $(BDEV_DEPS_THREAD)

5
mk/spdk.modules.mk
View File

@ -79,11 +79,6 @@ BLOCKDEV_MODULES_LIST += bdev_rbd
BLOCKDEV_MODULES_PRIVATE_LIBS += -lrados -lrbd
endif
ifeq ($(CONFIG_PMDK),y)
BLOCKDEV_MODULES_LIST += bdev_pmem
BLOCKDEV_MODULES_PRIVATE_LIBS += -lpmemblk -lpmem
endif
ifeq ($(CONFIG_DAOS),y)
BLOCKDEV_MODULES_LIST += bdev_daos
BLOCKDEV_MODULES_PRIVATE_LIBS += -ldaos -ldaos_common -ldfs -lgurt -luuid -ldl

1
module/bdev/Makefile
View File

@ -22,7 +22,6 @@ ifeq ($(OS),Linux)
DIRS-y += aio ftl
DIRS-$(CONFIG_ISCSI_INITIATOR) += iscsi
DIRS-$(CONFIG_VIRTIO) += virtio
DIRS-$(CONFIG_PMDK) += pmem
endif
DIRS-$(CONFIG_RBD) += rbd

17
module/bdev/pmem/Makefile
View File

@ -1,17 +0,0 @@
# 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
SO_VER := 5
SO_MINOR := 0
C_SRCS = bdev_pmem.c bdev_pmem_rpc.c
LIBNAME = bdev_pmem
SPDK_MAP_FILE = $(SPDK_ROOT_DIR)/mk/spdk_blank.map
include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk

412
module/bdev/pmem/bdev_pmem.c
View File

@ -1,412 +0,0 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright (C) 2017 Intel Corporation.
* All rights reserved.
*/
#include "spdk/string.h"
#include "spdk/likely.h"
#include "spdk/util.h"
#include "spdk/rpc.h"
#include "spdk/bdev_module.h"
#include "spdk/log.h"
#include "spdk/config.h"
#include "bdev_pmem.h"
#include "libpmemblk.h"
struct pmem_disk {
struct spdk_bdev disk;
PMEMblkpool *pool;
char pmem_file[NAME_MAX];
TAILQ_ENTRY(pmem_disk) tailq;
};
static TAILQ_HEAD(, pmem_disk) g_pmem_disks = TAILQ_HEAD_INITIALIZER(g_pmem_disks);
static int bdev_pmem_initialize(void);
static void bdev_pmem_finish(void);
static struct spdk_bdev_module pmem_if = {
.name = "pmem",
.module_init = bdev_pmem_initialize,
.module_fini = bdev_pmem_finish,
.async_fini = true,
};
SPDK_BDEV_MODULE_REGISTER(pmem, &pmem_if)
typedef int(*spdk_bdev_pmem_io_request)(PMEMblkpool *pbp, void *buf, long long blockno);
static int
_bdev_pmem_submit_io_read(PMEMblkpool *pbp, void *buf, long long blockno)
{
return pmemblk_read(pbp, buf, blockno);
}
static int
_bdev_pmem_submit_io_write(PMEMblkpool *pbp, void *buf, long long blockno)
{
return pmemblk_write(pbp, buf, blockno);
}
static int
bdev_pmem_destruct(void *ctx)
{
struct pmem_disk *pdisk = ctx;
TAILQ_REMOVE(&g_pmem_disks, pdisk, tailq);
free(pdisk->disk.name);
pmemblk_close(pdisk->pool);
free(pdisk);
return 0;
}
static int
bdev_pmem_check_iov_len(struct iovec *iovs, int iovcnt, size_t num_blocks, uint32_t block_size)
{
size_t nbytes = num_blocks * block_size;
int i;
for (i = 0; i < iovcnt; i++) {
if (spdk_unlikely(iovs[i].iov_base == NULL && iovs[i].iov_len != 0)) {
return -1;
}
if (nbytes <= iovs[i].iov_len) {
return 0;
}
if (spdk_unlikely(iovs[i].iov_len % block_size != 0)) {
return -1;
}
nbytes -= iovs[i].iov_len;
}
return -1;
}
static void
bdev_pmem_submit_io(struct spdk_bdev_io *bdev_io, struct pmem_disk *pdisk,
struct spdk_io_channel *ch,
struct iovec *iov, int iovcnt,
uint64_t offset_blocks, size_t num_blocks, uint32_t block_size,
spdk_bdev_pmem_io_request fn)
{
int rc;
size_t nbytes, offset, len;
enum spdk_bdev_io_status status;
rc = bdev_pmem_check_iov_len(iov, iovcnt, num_blocks, block_size);
if (rc) {
status = SPDK_BDEV_IO_STATUS_FAILED;
goto end;
}
SPDK_DEBUGLOG(bdev_pmem, "io %lu bytes from offset %#lx\n",
num_blocks, offset_blocks);
for (nbytes = num_blocks * block_size; nbytes > 0; iov++) {
len = spdk_min(iov->iov_len, nbytes);
nbytes -= len;
offset = 0;
while (offset != len) {
rc = fn(pdisk->pool, iov->iov_base + offset, offset_blocks);
if (rc != 0) {
SPDK_ERRLOG("pmemblk io failed: %d (%s)\n", errno, pmemblk_errormsg());
status = SPDK_BDEV_IO_STATUS_FAILED;
goto end;
}
offset += block_size;
offset_blocks++;
}
}
assert(num_blocks == offset_blocks - bdev_io->u.bdev.offset_blocks);
status = SPDK_BDEV_IO_STATUS_SUCCESS;
end:
spdk_bdev_io_complete(bdev_io, status);
}
static void
bdev_pmem_write_zeros(struct spdk_bdev_io *bdev_io, struct pmem_disk *pdisk,
struct spdk_io_channel *ch, uint64_t offset_blocks,
uint64_t num_blocks, uint32_t block_size)
{
int rc;
enum spdk_bdev_io_status status = SPDK_BDEV_IO_STATUS_SUCCESS;
while (num_blocks > 0) {
rc = pmemblk_set_zero(pdisk->pool, offset_blocks);
if (rc != 0) {
SPDK_ERRLOG("pmemblk_set_zero failed: %d (%s)\n", errno, pmemblk_errormsg());
status = SPDK_BDEV_IO_STATUS_FAILED;
break;
}
offset_blocks++;
num_blocks--;
}
spdk_bdev_io_complete(bdev_io, status);
}
static void
bdev_pmem_io_get_buf_cb(struct spdk_io_channel *channel, struct spdk_bdev_io *bdev_io,
bool success)
{
if (!success) {
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
return;
}
bdev_pmem_submit_io(bdev_io,
bdev_io->bdev->ctxt,
channel,
bdev_io->u.bdev.iovs,
bdev_io->u.bdev.iovcnt,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
bdev_io->bdev->blocklen,
_bdev_pmem_submit_io_read);
}
static void
bdev_pmem_submit_request(struct spdk_io_channel *channel, struct spdk_bdev_io *bdev_io)
{
switch (bdev_io->type) {
case SPDK_BDEV_IO_TYPE_READ:
spdk_bdev_io_get_buf(bdev_io, bdev_pmem_io_get_buf_cb,
bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
break;
case SPDK_BDEV_IO_TYPE_WRITE:
bdev_pmem_submit_io(bdev_io,
bdev_io->bdev->ctxt,
channel,
bdev_io->u.bdev.iovs,
bdev_io->u.bdev.iovcnt,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
bdev_io->bdev->blocklen,
_bdev_pmem_submit_io_write);
break;
case SPDK_BDEV_IO_TYPE_UNMAP:
case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
bdev_pmem_write_zeros(bdev_io,
bdev_io->bdev->ctxt,
channel,
bdev_io->u.bdev.offset_blocks,
bdev_io->u.bdev.num_blocks,
bdev_io->bdev->blocklen);
break;
case SPDK_BDEV_IO_TYPE_FLUSH:
case SPDK_BDEV_IO_TYPE_RESET:
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);
break;
default:
spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
}
}
static bool
bdev_pmem_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
{
switch (io_type) {
case SPDK_BDEV_IO_TYPE_READ:
case SPDK_BDEV_IO_TYPE_WRITE:
case SPDK_BDEV_IO_TYPE_RESET:
case SPDK_BDEV_IO_TYPE_UNMAP:
case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
case SPDK_BDEV_IO_TYPE_FLUSH:
return true;
default:
return false;
}
}
static struct spdk_io_channel *
bdev_pmem_get_io_channel(void *ctx)
{
return spdk_get_io_channel(&g_pmem_disks);
}
static int
bdev_pmem_dump_info_json(void *ctx, struct spdk_json_write_ctx *w)
{
struct pmem_disk *pdisk = ctx;
spdk_json_write_named_object_begin(w, "pmem");
spdk_json_write_named_string(w, "pmem_file", pdisk->pmem_file);
spdk_json_write_object_end(w);
return 0;
}
static int
bdev_pmem_create_cb(void *io_device, void *ctx_buf)
{
return 0;
}
static void
bdev_pmem_destroy_cb(void *io_device, void *ctx_buf)
{
}
static void
bdev_pmem_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *w)
{
struct pmem_disk *disk = bdev->ctxt;
spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "bdev_pmem_create");
spdk_json_write_named_object_begin(w, "params");
spdk_json_write_named_string(w, "name", bdev->name);
spdk_json_write_named_string(w, "pmem_file", disk->pmem_file);
spdk_json_write_object_end(w);
spdk_json_write_object_end(w);
}
static const struct spdk_bdev_fn_table pmem_fn_table = {
.destruct = bdev_pmem_destruct,
.submit_request = bdev_pmem_submit_request,
.io_type_supported = bdev_pmem_io_type_supported,
.get_io_channel = bdev_pmem_get_io_channel,
.dump_info_json = bdev_pmem_dump_info_json,
.write_config_json = bdev_pmem_write_config_json,
};
int
create_pmem_disk(const char *pmem_file, const char *name, struct spdk_bdev **bdev)
{
uint64_t num_blocks;
uint32_t block_size;
struct pmem_disk *pdisk;
int rc;
*bdev = NULL;
if (name == NULL) {
SPDK_ERRLOG("Missing name parameter for create_pmem_disk()\n");
return -EINVAL;
}
if (pmemblk_check(pmem_file, 0) != 1) {
SPDK_ERRLOG("Pool '%s' check failed: %s\n", pmem_file, pmemblk_errormsg());
return -EIO;
}
pdisk = calloc(1, sizeof(*pdisk));
if (!pdisk) {
return -ENOMEM;
}
snprintf(pdisk->pmem_file, sizeof(pdisk->pmem_file), "%s", pmem_file);
pdisk->pool = pmemblk_open(pmem_file, 0);
if (!pdisk->pool) {
SPDK_ERRLOG("Opening pmem pool '%s' failed: %d\n", pmem_file, errno);
free(pdisk);
return -errno;
}
block_size = pmemblk_bsize(pdisk->pool);
num_blocks = pmemblk_nblock(pdisk->pool);
if (block_size == 0) {
SPDK_ERRLOG("Block size must be more than 0 bytes\n");
pmemblk_close(pdisk->pool);
free(pdisk);
return -EINVAL;
}
if (num_blocks == 0) {
SPDK_ERRLOG("Disk must be more than 0 blocks\n");
pmemblk_close(pdisk->pool);
free(pdisk);
return -EINVAL;
}
pdisk->disk.name = strdup(name);
if (!pdisk->disk.name) {
pmemblk_close(pdisk->pool);
free(pdisk);
return -ENOMEM;
}
pdisk->disk.product_name = "pmemblk disk";
pdisk->disk.write_cache = 0;
pdisk->disk.blocklen = block_size;
pdisk->disk.blockcnt = num_blocks;
pdisk->disk.ctxt = pdisk;
pdisk->disk.fn_table = &pmem_fn_table;
pdisk->disk.module = &pmem_if;
rc = spdk_bdev_register(&pdisk->disk);
if (rc) {
pmemblk_close(pdisk->pool);
free(pdisk->disk.name);
free(pdisk);
return rc;
}
TAILQ_INSERT_TAIL(&g_pmem_disks, pdisk, tailq);
*bdev = &pdisk->disk;
return 0;
}
void
delete_pmem_disk(const char *name, spdk_delete_pmem_complete cb_fn, void *cb_arg)
{
int rc;
rc = spdk_bdev_unregister_by_name(name, &pmem_if, cb_fn, cb_arg);
if (rc != 0) {
cb_fn(cb_arg, rc);
}
}
SPDK_LOG_DEPRECATION_REGISTER(bdev_pmem, "PMDK libpmemblk bdev_pmem integration", "SPDK 23.05", 0);
static int
bdev_pmem_initialize(void)
{
const char *err = pmemblk_check_version(PMEMBLK_MAJOR_VERSION, PMEMBLK_MINOR_VERSION);
SPDK_LOG_DEPRECATED(bdev_pmem);
if (err != NULL) {
SPDK_ERRLOG("Invalid libpmemblk version (expected %d.%d): %s\n", PMEMBLK_MAJOR_VERSION,
PMEMBLK_MINOR_VERSION, err);
return -1;
}
#ifdef SPDK_CONFIG_DEBUG
setenv("PMEMBLK_LOG_LEVEL", "1", 1);
#endif
spdk_io_device_register(&g_pmem_disks, bdev_pmem_create_cb, bdev_pmem_destroy_cb, 0, "pmem_bdev");
return 0;
}
static void
bdev_pmem_finish_done(void *io_device)
{
spdk_bdev_module_fini_done();
}
static void
bdev_pmem_finish(void)
{
spdk_io_device_unregister(&g_pmem_disks, bdev_pmem_finish_done);
}
SPDK_LOG_REGISTER_COMPONENT(bdev_pmem)

36
module/bdev/pmem/bdev_pmem.h
View File

@ -1,36 +0,0 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright (C) 2017 Intel Corporation.
* All rights reserved.
*/
#ifndef SPDK_BDEV_PMEM_H
#define SPDK_BDEV_PMEM_H
#include "spdk/bdev.h"
typedef void (*spdk_delete_pmem_complete)(void *cb_arg, int bdeverrno);
/**
* Create new pmem bdev.
*
* \param pmem_file Pointer to pmem pool file.
* \param name Bdev name.
* \param bdev output parameter for bdev when operation is successful.
* \return 0 on success.
* -EIO if pool check failed
* -EINVAL if input parameters check failed
* -ENOMEM if buffer cannot be allocated
*/
int create_pmem_disk(const char *pmem_file, const char *name, struct spdk_bdev **bdev);
/**
* Delete pmem bdev.
*
* \param name Name of pmem bdev.
* \param cb_fn Function to call after deletion.
* \param cb_arg Argument to pass to cb_fn.
*/
void delete_pmem_disk(const char *name, spdk_delete_pmem_complete cb_fn,
void *cb_arg);
#endif /* SPDK_BDEV_PMEM_H */

293
module/bdev/pmem/bdev_pmem_rpc.c
View File

@ -1,293 +0,0 @@
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright (C) 2017 Intel Corporation.
* All rights reserved.
*/
#include "bdev_pmem.h"
#include "spdk/rpc.h"
#include "spdk/util.h"
#include "spdk/string.h"
#include "libpmemblk.h"
#include "spdk/log.h"
struct rpc_construct_pmem {
char *pmem_file;
char *name;
};
static void
free_rpc_bdev_pmem_create(struct rpc_construct_pmem *req)
{
free(req->pmem_file);
free(req->name);
}
static const struct spdk_json_object_decoder rpc_construct_pmem_decoders[] = {
{"pmem_file", offsetof(struct rpc_construct_pmem, pmem_file), spdk_json_decode_string},
{"name", offsetof(struct rpc_construct_pmem, name), spdk_json_decode_string},
};
static void
rpc_bdev_pmem_create(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_construct_pmem req = {};
struct spdk_json_write_ctx *w;
struct spdk_bdev *bdev;
int rc;
if (spdk_json_decode_object(params, rpc_construct_pmem_decoders,
SPDK_COUNTOF(rpc_construct_pmem_decoders),
&req)) {
SPDK_DEBUGLOG(bdev_pmem, "spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
rc = create_pmem_disk(req.pmem_file, req.name, &bdev);
if (rc != 0) {
spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
goto cleanup;
}
w = spdk_jsonrpc_begin_result(request);
spdk_json_write_string(w, spdk_bdev_get_name(bdev));
spdk_jsonrpc_end_result(request, w);
cleanup:
free_rpc_bdev_pmem_create(&req);
}
SPDK_RPC_REGISTER("bdev_pmem_create", rpc_bdev_pmem_create, SPDK_RPC_RUNTIME)
struct rpc_delete_pmem {
char *name;
};
static void
free_rpc_delete_pmem(struct rpc_delete_pmem *req)
{
free(req->name);
}
static const struct spdk_json_object_decoder rpc_delete_pmem_decoders[] = {
{"name", offsetof(struct rpc_delete_pmem, name), spdk_json_decode_string},
};
static void
_rpc_bdev_pmem_delete_cb(void *cb_arg, int bdeverrno)
{
struct spdk_jsonrpc_request *request = cb_arg;
if (bdeverrno == 0) {
spdk_jsonrpc_send_bool_response(request, true);
} else {
spdk_jsonrpc_send_error_response(request, bdeverrno, spdk_strerror(-bdeverrno));
}
}
static void
rpc_bdev_pmem_delete(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_delete_pmem req = {NULL};
if (spdk_json_decode_object(params, rpc_delete_pmem_decoders,
SPDK_COUNTOF(rpc_delete_pmem_decoders),
&req)) {
SPDK_DEBUGLOG(bdev_pmem, "spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
delete_pmem_disk(req.name, _rpc_bdev_pmem_delete_cb, request);
cleanup:
free_rpc_delete_pmem(&req);
}
SPDK_RPC_REGISTER("bdev_pmem_delete", rpc_bdev_pmem_delete, SPDK_RPC_RUNTIME)
struct rpc_bdev_pmem_create_pool {
char *pmem_file;
uint64_t num_blocks;
uint32_t block_size;
};
static const struct spdk_json_object_decoder rpc_bdev_pmem_create_pool_decoders[] = {
{"pmem_file", offsetof(struct rpc_bdev_pmem_create_pool, pmem_file), spdk_json_decode_string},
{"num_blocks", offsetof(struct rpc_bdev_pmem_create_pool, num_blocks), spdk_json_decode_uint64},
{"block_size", offsetof(struct rpc_bdev_pmem_create_pool, block_size), spdk_json_decode_uint32},
};
static void
free_rpc_bdev_pmem_create_pool(struct rpc_bdev_pmem_create_pool *req)
{
free(req->pmem_file);
}
static void
rpc_bdev_pmem_create_pool(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_bdev_pmem_create_pool req = {};
uint64_t pool_size;
PMEMblkpool *pbp;
if (spdk_json_decode_object(params, rpc_bdev_pmem_create_pool_decoders,
SPDK_COUNTOF(rpc_bdev_pmem_create_pool_decoders),
&req)) {
SPDK_DEBUGLOG(bdev_pmem, "spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
/* libpmemblk pool has to contain at least 256 blocks */
if (req.num_blocks < 256) {
spdk_jsonrpc_send_error_response(request, -EINVAL,
"Pmem pool num_blocks must be at least 256");
goto cleanup;
}
pool_size = req.num_blocks * req.block_size;
if (pool_size < PMEMBLK_MIN_POOL) {
spdk_jsonrpc_send_error_response_fmt(request, -EINVAL,
"Pmem pool size must be at least %ld", PMEMBLK_MIN_POOL);
goto cleanup;
}
pbp = pmemblk_create(req.pmem_file, req.block_size, pool_size, 0666);
if (pbp == NULL) {
const char *msg = pmemblk_errormsg();
SPDK_DEBUGLOG(bdev_pmem, "pmemblk_create() failed: %s\n", msg ? msg : "(logs disabled)");
spdk_jsonrpc_send_error_response_fmt(request, -SPDK_JSONRPC_ERROR_INVALID_PARAMS,
"pmemblk_create failed: %s", msg ? msg : "(logs disabled)");
goto cleanup;
}
pmemblk_close(pbp);
spdk_jsonrpc_send_bool_response(request, true);
cleanup:
free_rpc_bdev_pmem_create_pool(&req);
}
SPDK_RPC_REGISTER("bdev_pmem_create_pool", rpc_bdev_pmem_create_pool, SPDK_RPC_RUNTIME)
struct rpc_bdev_pmem_get_pool_info {
char *pmem_file;
};
static const struct spdk_json_object_decoder rpc_bdev_pmem_get_pool_info_decoders[] = {
{"pmem_file", offsetof(struct rpc_bdev_pmem_get_pool_info, pmem_file), spdk_json_decode_string},
};
static void
free_rpc_bdev_pmem_get_pool_info(struct rpc_bdev_pmem_get_pool_info *req)
{
free(req->pmem_file);
}
static void
rpc_bdev_pmem_get_pool_info(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_bdev_pmem_get_pool_info req = {};
struct spdk_json_write_ctx *w;
size_t num_blocks, block_size;
PMEMblkpool *pbp;
if (spdk_json_decode_object(params, rpc_bdev_pmem_get_pool_info_decoders,
SPDK_COUNTOF(rpc_bdev_pmem_get_pool_info_decoders),
&req)) {
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
pbp = pmemblk_open(req.pmem_file, 0);
if (pbp == NULL) {
const char *msg = pmemblk_errormsg();
spdk_jsonrpc_send_error_response_fmt(request, -SPDK_JSONRPC_ERROR_INVALID_PARAMS,
"pmemblk_open failed: %s", msg ? msg : "(logs disabled)");
goto cleanup;
}
block_size = pmemblk_bsize(pbp);
num_blocks = pmemblk_nblock(pbp);
pmemblk_close(pbp);
/* Check pmem pool consistency */
if (pmemblk_check(req.pmem_file, block_size) != 1) {
const char *msg = pmemblk_errormsg();
spdk_jsonrpc_send_error_response_fmt(request, -SPDK_JSONRPC_ERROR_INVALID_PARAMS,
"pmemblk_check failed: %s", msg ? msg : "(logs disabled)");
goto cleanup;
}
w = spdk_jsonrpc_begin_result(request);
spdk_json_write_array_begin(w);
spdk_json_write_object_begin(w);
spdk_json_write_named_uint64(w, "num_blocks", num_blocks);
spdk_json_write_named_uint64(w, "block_size", block_size);
spdk_json_write_object_end(w);
spdk_json_write_array_end(w);
spdk_jsonrpc_end_result(request, w);
cleanup:
free_rpc_bdev_pmem_get_pool_info(&req);
}
SPDK_RPC_REGISTER("bdev_pmem_get_pool_info", rpc_bdev_pmem_get_pool_info, SPDK_RPC_RUNTIME)
struct rpc_bdev_pmem_delete_pool {
char *pmem_file;
};
static const struct spdk_json_object_decoder rpc_bdev_pmem_delete_pool_decoders[] = {
{"pmem_file", offsetof(struct rpc_bdev_pmem_delete_pool, pmem_file), spdk_json_decode_string},
};
static void
free_rpc_bdev_pmem_delete_pool(struct rpc_bdev_pmem_delete_pool *req)
{
free(req->pmem_file);
}
static void
rpc_bdev_pmem_delete_pool(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_bdev_pmem_delete_pool req = {};
int rc;
if (spdk_json_decode_object(params, rpc_bdev_pmem_delete_pool_decoders,
SPDK_COUNTOF(rpc_bdev_pmem_delete_pool_decoders),
&req)) {
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
goto cleanup;
}
/* Check if file is actually pmem pool */
rc = pmemblk_check(req.pmem_file, 0);
if (rc != 1) {
const char *msg = pmemblk_errormsg();
spdk_jsonrpc_send_error_response_fmt(request, -SPDK_JSONRPC_ERROR_INVALID_PARAMS,
"pmemblk_check failed: %s", msg ? msg : "(logs disabled)");
goto cleanup;
}
unlink(req.pmem_file);
spdk_jsonrpc_send_bool_response(request, true);
cleanup:
free_rpc_bdev_pmem_delete_pool(&req);
}
SPDK_RPC_REGISTER("bdev_pmem_delete_pool", rpc_bdev_pmem_delete_pool, SPDK_RPC_RUNTIME)

1
python/spdk/rpc/__init__.py
View File

@ -25,7 +25,6 @@ from . import ublk
from . import notify
from . import nvme
from . import nvmf
from . import pmem
from . import subsystem
from . import trace
from . import vhost

27
python/spdk/rpc/bdev.py
View File

@ -1272,33 +1272,6 @@ def bdev_iscsi_delete(client, name):
return client.call('bdev_iscsi_delete', params)
def bdev_pmem_create(client, pmem_file, name):
"""Construct a libpmemblk block device.
Args:
pmem_file: path to pmemblk pool file
name: name of block device
Returns:
Name of created block device.
"""
params = {
'pmem_file': pmem_file,
'name': name
}
return client.call('bdev_pmem_create', params)
def bdev_pmem_delete(client, name):
"""Remove pmem bdev from the system.
Args:
name: name of pmem bdev to delete
"""
params = {'name': name}
return client.call('bdev_pmem_delete', params)
def bdev_passthru_create(client, base_bdev_name, name):
"""Construct a pass-through block device.

34
python/spdk/rpc/pmem.py
View File

@ -1,34 +0,0 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright (C) 2017 Intel Corporation.
# All rights reserved.
def bdev_pmem_create_pool(client, pmem_file, num_blocks, block_size):
"""Create pmem pool at specified path.
Args:
pmem_file: path at which to create pmem pool
num_blocks: number of blocks for created pmem pool file
block_size: block size for pmem pool file
"""
params = {'pmem_file': pmem_file,
'num_blocks': num_blocks,
'block_size': block_size}
return client.call('bdev_pmem_create_pool', params)
def bdev_pmem_get_pool_info(client, pmem_file):
"""Get details about pmem pool.
Args:
pmem_file: path to pmem pool
"""
params = {'pmem_file': pmem_file}
return client.call('bdev_pmem_get_pool_info', params)
def bdev_pmem_delete_pool(client, pmem_file):
"""Delete pmem pool.
Args:
pmem_file: path to pmem pool
"""
params = {'pmem_file': pmem_file}
return client.call('bdev_pmem_delete_pool', params)

42
python/spdk/spdkcli/ui_node.py
View File

@ -53,8 +53,7 @@ class UINode(ConfigNode):
command in ["create", "delete", "delete_all", "add_initiator",
"allow_any_host", "bdev_split_create", "add_lun",
"iscsi_target_node_add_pg_ig_maps", "remove_target", "add_secret",
"bdev_split_delete", "bdev_pmem_delete_pool",
"bdev_pmem_create_pool", "delete_secret_all",
"bdev_split_delete", "delete_secret_all",
"delete_initiator", "set_auth", "delete_secret",
"iscsi_target_node_remove_pg_ig_maps", "load_config",
"load_subsystem_config"]:
@ -76,7 +75,6 @@ class UIBdevs(UINode):
UINullBdev(self)
UIErrorBdev(self)
UISplitBdev(self)
UIPmemBdev(self)
UIRbdBdev(self)
UIiSCSIBdev(self)
UIVirtioBlkBdev(self)
@ -424,44 +422,6 @@ class UISplitBdev(UIBdev):
self.get_root().bdev_split_delete(base_bdev=base_bdev)
class UIPmemBdev(UIBdev):
def __init__(self, parent):
UIBdev.__init__(self, "pmemblk", parent)
def delete(self, name):
self.get_root().bdev_pmem_delete(name=name)
def ui_command_bdev_pmem_create_pool(self, pmem_file, total_size, block_size):
total_size = self.ui_eval_param(total_size, "number", None)
block_size = self.ui_eval_param(block_size, "number", None)
num_blocks = int((total_size * 1024 * 1024) / block_size)
self.get_root().bdev_pmem_create_pool(pmem_file=pmem_file,
num_blocks=num_blocks,
block_size=block_size)
def ui_command_bdev_pmem_delete_pool(self, pmem_file):
self.get_root().bdev_pmem_delete_pool(pmem_file=pmem_file)
def ui_command_bdev_pmem_get_pool_info(self, pmem_file):
ret = self.get_root().bdev_pmem_get_pool_info(pmem_file=pmem_file)
self.shell.log.info(json.dumps(ret, indent=2))
def ui_command_create(self, pmem_file, name):
ret_name = self.get_root().bdev_pmem_create(pmem_file=pmem_file,
name=name)
self.shell.log.info(ret_name)
def ui_command_delete(self, name):
"""
Deletes pmem bdev from configuration.
Arguments:
name - Is a unique identifier of the pmem bdev to be deleted - UUID number or name alias.
"""
self.delete(name)
class UIRbdBdev(UIBdev):
def __init__(self, parent):
UIBdev.__init__(self, "rbd", parent)

24
python/spdk/spdkcli/ui_root.py
View File

@ -208,30 +208,6 @@ class UIRoot(UINode):
def bdev_lvol_delete_lvstore(self, **kwargs):
rpc.lvol.bdev_lvol_delete_lvstore(self.client, **kwargs)
@verbose
def bdev_pmem_create_pool(self, **kwargs):
response = rpc.pmem.bdev_pmem_create_pool(self.client, **kwargs)
return response
@verbose
def bdev_pmem_delete_pool(self, **kwargs):
rpc.pmem.bdev_pmem_delete_pool(self.client, **kwargs)
@verbose
def bdev_pmem_get_pool_info(self, **kwargs):
response = rpc.pmem.bdev_pmem_get_pool_info(self.client, **kwargs)
return response
@verbose
def bdev_pmem_create(self, **kwargs):
response = rpc.bdev.bdev_pmem_create(self.client, **kwargs)
return response
@verbose
def bdev_pmem_delete(self, **kwargs):
response = rpc.bdev.bdev_pmem_delete(self.client, **kwargs)
return response
@verbose
def create_rbd_bdev(self, **kwargs):
response = rpc.bdev.bdev_rbd_create(self.client, **kwargs)

2
scripts/pkgdep.sh
View File

@ -17,7 +17,7 @@ function usage() {
echo " -h --help"
echo " -a --all"
echo " -d --developer-tools Install tools for developers (code styling, code coverage, etc.)"
echo " -p --pmem Additional dependencies for reduce, pmdk and pmdkobj"
echo " -p --pmem Additional dependencies for reduce"
echo " -f --fuse Additional dependencies for FUSE and NVMe-CUSE"
echo " -R --rbd Additional dependencies for RBD"
echo " -r --rdma Additional dependencies for RDMA transport in NVMe over Fabrics"

1
scripts/pkgdep/debian.sh
View File

@ -59,7 +59,6 @@ if [[ $INSTALL_PMEM == "true" ]]; then
# Additional dependencies for building pmem based backends
if [[ $NAME == "Ubuntu" ]] && [[ $VERSION_ID_NUM -gt 1800 ]]; then
apt-get install -y libpmem-dev
apt-get install -y libpmemblk-dev
apt-get install -y libpmemobj-dev
fi
fi

1
scripts/pkgdep/rhel.sh
View File

@ -150,7 +150,6 @@ if [[ $INSTALL_DEV_TOOLS == "true" ]]; then
fi
if [[ $INSTALL_PMEM == "true" ]]; then
# Additional dependencies for building pmem based backends
yum install -y libpmemblk-devel || true
yum install -y libpmemobj-devel || true
fi
if [[ $INSTALL_FUSE == "true" ]]; then

1
scripts/pkgdep/sles.sh
View File

@ -19,7 +19,6 @@ if [[ $INSTALL_DEV_TOOLS == "true" ]]; then
fi
if [[ $INSTALL_PMEM == "true" ]]; then
# Additional dependencies for building pmem based backends
zypper install -y libpmemblk-devel
zypper install -y libpmemobj-devel
fi
if [[ $INSTALL_FUSE == "true" ]]; then

48
scripts/rpc.py
View File

@ -1110,24 +1110,6 @@ if __name__ == "__main__":
p.add_argument('name', help='iSCSI bdev name')
p.set_defaults(func=bdev_iscsi_delete)
def bdev_pmem_create(args):
print_json(rpc.bdev.bdev_pmem_create(args.client,
pmem_file=args.pmem_file,
name=args.name))
p = subparsers.add_parser('bdev_pmem_create', help='Add a bdev with pmem backend')
p.add_argument('pmem_file', help='Path to pmemblk pool file')
p.add_argument('-n', '--name', help='Block device name', required=True)
p.set_defaults(func=bdev_pmem_create)
def bdev_pmem_delete(args):
rpc.bdev.bdev_pmem_delete(args.client,
name=args.name)
p = subparsers.add_parser('bdev_pmem_delete', help='Delete a pmem bdev')
p.add_argument('name', help='pmem bdev name')
p.set_defaults(func=bdev_pmem_delete)
def bdev_passthru_create(args):
print_json(rpc.bdev.bdev_passthru_create(args.client,
base_bdev_name=args.base_bdev_name,
@ -2593,36 +2575,6 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.add_argument('-t3', '--crdt3', help='Command Retry Delay Time 3, in units of 100 milliseconds', type=int)
p.set_defaults(func=nvmf_set_crdt)
# pmem
def bdev_pmem_create_pool(args):
num_blocks = int((args.total_size * 1024 * 1024) / args.block_size)
rpc.pmem.bdev_pmem_create_pool(args.client,
pmem_file=args.pmem_file,
num_blocks=num_blocks,
block_size=args.block_size)
p = subparsers.add_parser('bdev_pmem_create_pool', help='Create pmem pool')
p.add_argument('pmem_file', help='Path to pmemblk pool file')
p.add_argument('total_size', help='Size of pmem bdev in MB (int > 0)', type=int)
p.add_argument('block_size', help='Block size for this pmem pool', type=int)
p.set_defaults(func=bdev_pmem_create_pool)
def bdev_pmem_get_pool_info(args):
print_dict(rpc.pmem.bdev_pmem_get_pool_info(args.client,
pmem_file=args.pmem_file))
p = subparsers.add_parser('bdev_pmem_get_pool_info', help='Display pmem pool info and check consistency')
p.add_argument('pmem_file', help='Path to pmemblk pool file')
p.set_defaults(func=bdev_pmem_get_pool_info)
def bdev_pmem_delete_pool(args):
rpc.pmem.bdev_pmem_delete_pool(args.client,
pmem_file=args.pmem_file)
p = subparsers.add_parser('bdev_pmem_delete_pool', help='Delete pmem pool')
p.add_argument('pmem_file', help='Path to pmemblk pool file')
p.set_defaults(func=bdev_pmem_delete_pool)
# subsystem
def framework_get_subsystems(args):
print_dict(rpc.subsystem.framework_get_subsystems(args.client))

7
test/common/autotest_common.sh
View File

@ -128,8 +128,6 @@ export SPDK_TEST_IOAT
export SPDK_TEST_BLOBFS
: ${SPDK_TEST_VHOST_INIT=0}
export SPDK_TEST_VHOST_INIT
: ${SPDK_TEST_PMDK=0}
export SPDK_TEST_PMDK
: ${SPDK_TEST_LVOL=0}
export SPDK_TEST_LVOL
: ${SPDK_TEST_VBDEV_COMPRESS=0}
@ -439,11 +437,6 @@ function get_config_params() {
config_params+=' --with-nvme-cuse'
fi
# for options with both dependencies and a test flag, set them here
if [ -f /usr/include/libpmemblk.h ] && [ $SPDK_TEST_PMDK -eq 1 ]; then
config_params+=' --with-pmdk'
fi
if [ -f /usr/include/libpmem.h ] && [ $SPDK_TEST_VBDEV_COMPRESS -eq 1 ]; then
if ge "$(nasm --version | awk '{print $3}')" 2.14 && [[ $SPDK_TEST_ISAL -eq 1 ]]; then
config_params+=' --with-vbdev-compress --with-dpdk-compressdev'

1
test/spdkcli/match_files/spdkcli_raid.test.match
View File

@ -8,7 +8,6 @@ o- bdevs .......................................................................
| o- Malloc2 $(S) [$(UUID), Size=8.0M, Claimed]
o- null ............................................................................................................... [Bdevs: 0]
o- nvme ............................................................................................................... [Bdevs: 0]
o- pmemblk ............................................................................................................ [Bdevs: 0]
o- raid_volume ........................................................................................................ [Bdevs: 1]
| o- testraid $(S) [Size=16.0M, Not claimed]
o- rbd ................................................................................................................ [Bdevs: 0]

1
test/spdkcli/match_files/spdkcli_vhost.test.match
View File

@ -23,7 +23,6 @@ o- / ...........................................................................
| o- nvme ............................................................................................................. [Bdevs: 1]
$(OPT) | | o- Nvme0n1 $(S) [Size=$(S), Claimed]
$(OPX) | | o- Nvme0n1 $(S) [$(UUID), Size=$(S), Claimed]
| o- pmemblk .......................................................................................................... [Bdevs: 0]
| o- raid_volume ...................................................................................................... [Bdevs: 0]
| o- rbd .............................................................................................................. [Bdevs: 0]
| o- split_disk ....................................................................................................... [Bdevs: 4]

1
test/spdkcli/match_files/spdkcli_virtio_pci.test.match
View File

@ -8,7 +8,6 @@ o- bdevs .......................................................................
| o- Malloc1 ........................................................................................... [Size=32.0M, Not claimed]
o- null ............................................................................................................... [Bdevs: 0]
o- nvme ............................................................................................................... [Bdevs: 0]
o- pmemblk ............................................................................................................ [Bdevs: 0]
o- raid_volume ........................................................................................................ [Bdevs: 0]
o- rbd ................................................................................................................ [Bdevs: 0]
o- split_disk ......................................................................................................... [Bdevs: 0]