d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bdev: add delete_malloc_bdev call

Browse Source 
Since delete_bdev should be used only for debug purpose,
this patch adds delete call specific for malloc.

Changes in tests and spdkcli done accordingly.

Change-Id: I5296452f552ee6eaba4d012d47aea022f17b9d6e
Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-on: https://review.gerrithub.io/415259
Reviewed-by: Karol Latecki <karol.latecki@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Tested-by: SPDK Automated Test System <sys_sgsw@intel.com>
This commit is contained in:
Tomasz Zawadzki 2018-06-15 03:58:57 -04:00 committed by Jim Harris
parent 635a1aa8a9
commit 59dee78bd6
13 changed files with 162 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lib/bdev/malloc/bdev_malloc.c
View File

@ -448,6 +448,17 @@ struct spdk_bdev *create_malloc_disk(const char *name, const struct spdk_uuid *u
return &mdisk->disk;
}
void
delete_malloc_disk(struct spdk_bdev *bdev, spdk_delete_malloc_complete cb_fn, void *cb_arg)
{
if (!bdev || bdev->module != &malloc_if) {
cb_fn(cb_arg, -ENODEV);
return;
}
spdk_bdev_unregister(bdev, cb_fn, cb_arg);
}
static int bdev_malloc_initialize(void)
{
struct spdk_conf_section *sp = spdk_conf_find_section(NULL, "Malloc");

4
lib/bdev/malloc/bdev_malloc.h
View File

@ -38,7 +38,11 @@
#include "spdk/bdev.h"
typedef void (*spdk_delete_malloc_complete)(void *cb_arg, int bdeverrno);
struct spdk_bdev *create_malloc_disk(const char *name, const struct spdk_uuid *uuid,
uint64_t num_blocks, uint32_t block_size);
void delete_malloc_disk(struct spdk_bdev *bdev, spdk_delete_malloc_complete cb_fn, void *cb_arg);
#endif /* SPDK_BDEV_MALLOC_H */

66
lib/bdev/malloc/bdev_malloc_rpc.c
View File

@ -35,7 +35,7 @@
#include "spdk/rpc.h"
#include "spdk/util.h"
#include "spdk/uuid.h"
#include "spdk/string.h"
#include "spdk_internal/log.h"
struct rpc_construct_malloc {
@ -106,3 +106,67 @@ invalid:
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
}
SPDK_RPC_REGISTER("construct_malloc_bdev", spdk_rpc_construct_malloc_bdev, SPDK_RPC_RUNTIME)
struct rpc_delete_malloc {
char *name;
};
static void
free_rpc_delete_malloc(struct rpc_delete_malloc *r)
{
free(r->name);
}
static const struct spdk_json_object_decoder rpc_delete_malloc_decoders[] = {
{"name", offsetof(struct rpc_delete_malloc, name), spdk_json_decode_string},
};
static void
_spdk_rpc_delete_malloc_bdev_cb(void *cb_arg, int bdeverrno)
{
struct spdk_jsonrpc_request *request = cb_arg;
struct spdk_json_write_ctx *w;
w = spdk_jsonrpc_begin_result(request);
if (w == NULL) {
return;
}
spdk_json_write_bool(w, bdeverrno == 0);
spdk_jsonrpc_end_result(request, w);
}
static void
spdk_rpc_delete_malloc_bdev(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_delete_malloc req = {NULL};
struct spdk_bdev *bdev;
int rc;
if (spdk_json_decode_object(params, rpc_delete_malloc_decoders,
SPDK_COUNTOF(rpc_delete_malloc_decoders),
&req)) {
SPDK_DEBUGLOG(SPDK_LOG_BDEV_MALLOC, "spdk_json_decode_object failed\n");
rc = -EINVAL;
goto invalid;
}
bdev = spdk_bdev_get_by_name(req.name);
if (bdev == NULL) {
SPDK_INFOLOG(SPDK_LOG_BDEV_MALLOC, "bdev '%s' does not exist\n", req.name);
rc = -ENODEV;
goto invalid;
}
delete_malloc_disk(bdev, _spdk_rpc_delete_malloc_bdev_cb, request);
free_rpc_delete_malloc(&req);
return;
invalid:
free_rpc_delete_malloc(&req);
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INVALID_PARAMS, spdk_strerror(-rc));
}
SPDK_RPC_REGISTER("delete_malloc_bdev", spdk_rpc_delete_malloc_bdev, SPDK_RPC_RUNTIME)

9
scripts/rpc.py
View File

@ -139,6 +139,15 @@ if __name__ == "__main__":
p.add_argument('block_size', help='Block size for this bdev', type=int)
p.set_defaults(func=construct_malloc_bdev)
@call_cmd
def delete_malloc_bdev(args):
rpc.bdev.delete_malloc_bdev(args.client,
name=args.name)
p = subparsers.add_parser('delete_malloc_bdev', help='Delete a malloc disk')
p.add_argument('name', help='malloc bdev name')
p.set_defaults(func=delete_malloc_bdev)
@call_cmd
def construct_null_bdev(args):
num_blocks = (args.total_size * 1024 * 1024) // args.block_size

10
scripts/rpc/bdev.py
View File

@ -35,6 +35,16 @@ def construct_malloc_bdev(client, num_blocks, block_size, name=None, uuid=None):
return client.call('construct_malloc_bdev', params)
def delete_malloc_bdev(client, name):
"""Delete malloc block device.
Args:
bdev_name: name of malloc bdev to delete
"""
params = {'name': name}
return client.call('delete_malloc_bdev', params)
def construct_null_bdev(client, num_blocks, block_size, name, uuid=None):
"""Construct a null block device.

11
scripts/spdkcli/ui_node.py
View File

@ -202,6 +202,17 @@ class UIMallocBdev(UIBdev):
self.get_root().refresh()
self.refresh()
def ui_command_delete(self, name):
"""
Deletes malloc bdev from configuration.
Arguments:
name - Is a unique identifier of the malloc bdev to be deleted - UUID number or name alias.
"""
self.get_root().delete_malloc_bdev(name=name)
self.get_root().refresh()
self.refresh()
class UIAIOBdev(UIBdev):
def __init__(self, parent):

3
scripts/spdkcli/ui_root.py
View File

@ -53,6 +53,9 @@ class UIRoot(UINode):
response = rpc.bdev.construct_malloc_bdev(self.client, **kwargs)
return self.print_array(response)
def delete_malloc_bdev(self, **kwargs):
rpc.bdev.delete_malloc_bdev(self.client, **kwargs)
def create_aio_bdev(self, **kwargs):
response = rpc.bdev.construct_aio_bdev(self.client, **kwargs)
return self.print_array(response)

2
test/json_config/clear_config.py
View File

@ -49,7 +49,7 @@ def get_bdev_destroy_method(bdev):
destroy_method_map = {'construct_nvme_bdev': "delete_bdev",
'construct_pmem_bdev': "delete_bdev",
'construct_rbd_bdev': "delete_bdev",
'construct_malloc_bdev': "delete_bdev",
'construct_malloc_bdev': "delete_malloc_bdev",
'construct_null_bdev': "delete_bdev",
'construct_aio_bdev': "delete_aio_bdev",
'construct_error_bdev': "delete_bdev",

5
test/lvol/rpc_commands_lib.py
View File

@ -147,6 +147,11 @@ class Commands_Rpc(object):
output, rc = self.rpc.delete_bdev(base_name)
return rc
def delete_malloc_bdev(self, base_name):
print("INFO: RPC COMMAND delete_malloc_bdev")
output, rc = self.rpc.delete_malloc_bdev(base_name)
return rc
def destroy_lvol_bdev(self, bdev_name):
print("INFO: RPC COMMAND destroy_lvol_bdev")
output, rc = self.rpc.destroy_lvol_bdev(bdev_name)

68
test/lvol/test_cases.py
View File

@ -278,7 +278,7 @@ class TestCases(object):
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
self.cluster_size)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
return fail_count
@ -299,7 +299,7 @@ class TestCases(object):
self.total_size - 1)
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -326,7 +326,7 @@ class TestCases(object):
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -349,7 +349,7 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_bdev(uuid_bdev)
fail_count += self.c.destroy_lvol_store(uuid_store)
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -383,8 +383,8 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_bdev(uuid_bdev_2)
fail_count += self.c.destroy_lvol_store(uuid_store_1)
fail_count += self.c.destroy_lvol_store(uuid_store_2)
fail_count += self.c.delete_bdev(base_name_1)
fail_count += self.c.delete_bdev(base_name_2)
fail_count += self.c.delete_malloc_bdev(base_name_1)
fail_count += self.c.delete_malloc_bdev(base_name_2)
return fail_count
@case_message
@ -417,7 +417,7 @@ class TestCases(object):
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -442,7 +442,7 @@ class TestCases(object):
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -476,7 +476,7 @@ class TestCases(object):
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -505,7 +505,7 @@ class TestCases(object):
self.c.destroy_lvol_bdev(uuid_bdev)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -520,7 +520,7 @@ class TestCases(object):
self.c.destroy_lvol_store(uuid_store)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -535,7 +535,7 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_store(self.lvs_name)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -557,7 +557,7 @@ class TestCases(object):
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -580,7 +580,7 @@ class TestCases(object):
self.c.destroy_lvol_store(uuid_store)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -617,7 +617,7 @@ class TestCases(object):
self.c.destroy_lvol_store(uuid_store)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -662,7 +662,7 @@ class TestCases(object):
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
self.cluster_size)
if self.c.delete_bdev(base_name) != 0:
if self.c.delete_malloc_bdev(base_name) != 0:
fail_count += 1
if self.c.destroy_lvol_store(uuid_store) == 0:
@ -705,7 +705,7 @@ class TestCases(object):
self.cluster_size) == 0:
fail_count += 1
self.c.destroy_lvol_store(uuid_store)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -727,8 +727,8 @@ class TestCases(object):
fail_count += 1
fail_count += self.c.destroy_lvol_store(uuid_store_1)
fail_count += self.c.delete_bdev(base_name_1)
fail_count += self.c.delete_bdev(base_name_2)
fail_count += self.c.delete_malloc_bdev(base_name_1)
fail_count += self.c.delete_malloc_bdev(base_name_2)
return fail_count
@ -746,7 +746,7 @@ class TestCases(object):
self.cluster_size)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
self.cluster_size)
self.c.delete_bdev(base_name)
self.c.delete_malloc_bdev(base_name)
if self.c.check_get_lvol_stores("", "", "") == 1:
fail_count += 1
return fail_count
@ -761,7 +761,7 @@ class TestCases(object):
(self.total_size * 1024 * 1024) + 1) == 0
if self.c.check_get_lvol_stores(base_name, lvol_uuid) == 0:
fail_count += 1
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -772,7 +772,7 @@ class TestCases(object):
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, 8191)
if self.c.check_get_lvol_stores(base_name, lvol_uuid) == 0:
fail_count += 1
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
return fail_count
@case_message
@ -1290,7 +1290,7 @@ class TestCases(object):
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc bdev
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1367,7 +1367,7 @@ class TestCases(object):
# Destroy snapshot
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc bdev
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1427,7 +1427,7 @@ class TestCases(object):
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc bdevs
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1474,7 +1474,7 @@ class TestCases(object):
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc bdev
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1537,7 +1537,7 @@ class TestCases(object):
# Delete lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Destroy malloc bdev
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1611,7 +1611,7 @@ class TestCases(object):
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1704,7 +1704,7 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1796,7 +1796,7 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_store(uuid_store)
# Delete malloc
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
@ -1871,7 +1871,7 @@ class TestCases(object):
for bdev in new_bdev_aliases:
fail_count += self.c.destroy_lvol_bdev(bdev)
fail_count += self.c.destroy_lvol_store(new_lvs_name)
fail_count += self.c.delete_bdev(base_name)
fail_count += self.c.delete_malloc_bdev(base_name)
return fail_count
@ -1966,8 +1966,8 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_bdev(lvol_uuid)
fail_count += self.c.destroy_lvol_store(lvs_uuid_1)
fail_count += self.c.destroy_lvol_store(lvs_uuid_2)
fail_count += self.c.delete_bdev(base_bdev_1)
fail_count += self.c.delete_bdev(base_bdev_2)
fail_count += self.c.delete_malloc_bdev(base_bdev_1)
fail_count += self.c.delete_malloc_bdev(base_bdev_2)
return fail_count
@ -2012,7 +2012,7 @@ class TestCases(object):
fail_count += self.c.destroy_lvol_bdev(bdev_uuid_1)
fail_count += self.c.destroy_lvol_bdev(bdev_uuid_2)
fail_count += self.c.destroy_lvol_store(lvs_uuid)
fail_count += self.c.delete_bdev(base_bdev)
fail_count += self.c.delete_malloc_bdev(base_bdev)
return fail_count

12
test/nvmf/fio/fio.sh
View File

@ -30,15 +30,15 @@ trap "killprocess $nvmfpid; exit 1" SIGINT SIGTERM EXIT
waitforlisten $nvmfpid
timing_exit start_nvmf_tgt
bdevs="$bdevs $($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
bdevs="$bdevs $($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
malloc_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
modprobe -v nvme-rdma
$rpc_py construct_nvmf_subsystem nqn.2016-06.io.spdk:cnode1 "trtype:RDMA traddr:$NVMF_FIRST_TARGET_IP trsvcid:4420" "" -a -s SPDK00000000000001
for bdev in $bdevs; do
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 "$bdev"
for malloc_bdev in $malloc_bdevs; do
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 "$malloc_bdev"
done
nvme connect -t rdma -n "nqn.2016-06.io.spdk:cnode1" -a "$NVMF_FIRST_TARGET_IP" -s "$NVMF_PORT"
@ -60,8 +60,8 @@ fio_pid=$!
sleep 3
set +e
for bdev in $bdevs; do
$rpc_py delete_bdev "$bdev"
for malloc_bdev in $malloc_bdevs; do
$rpc_py delete_malloc_bdev "$malloc_bdev"
done
wait $fio_pid

4
test/nvmf/host/aer.sh
View File

@ -63,8 +63,8 @@ $rpc_py get_nvmf_subsystems
wait $aerpid
$rpc_py delete_bdev Malloc0
$rpc_py delete_bdev Malloc1
$rpc_py delete_malloc_bdev Malloc0
$rpc_py delete_malloc_bdev Malloc1
$rpc_py delete_nvmf_subsystem nqn.2016-06.io.spdk:cnode1
trap - SIGINT SIGTERM EXIT

2
test/vhost/migration/migration-tc1.sh
View File

@ -5,7 +5,7 @@ function migration_tc1_clean_vhost_config()
notice "Removing vhost devices & controllers via RPC ..."
# Delete bdev first to remove all LUNs and SCSI targets
$rpc delete_bdev Malloc0
$rpc delete_malloc_bdev Malloc0
# Delete controllers
$rpc remove_vhost_controller $incoming_vm_ctrlr