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

RPC: rename rpc construct_raid_bdev to bdev_raid_create

Browse Source 
Signed-off-by: Maciej Wawryk <maciejx.wawryk@intel.com>
Change-Id: I15e33d85d2ecb058dd8e73219537df262a0077be
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/467917
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Maciej Wawryk 2019-09-10 10:41:05 +02:00 committed by Jim Harris
parent b9477173a3
commit f07315342c
15 changed files with 151 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/bdev.md
View File

@ -473,7 +473,7 @@ Example commands
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
store on-disk metadata on the member disks, so user must reconstruct the RAID
store on-disk metadata on the member disks, so user must recreate the RAID
volume when restarting application. User may specify member disks to create RAID
volume event if they do not exists yet - as the member disks are registered at
a later time, the RAID module will claim them and will surface the RAID volume
@ -483,7 +483,7 @@ each member disk.
Example commands
`rpc.py construct_raid_bdev -n Raid0 -z 64 -r 0 -b "lvol0 lvol1 lvol2 lvol3"`
`rpc.py bdev_raid_create -n Raid0 -z 64 -r 0 -b "lvol0 lvol1 lvol2 lvol3"`
`rpc.py bdev_raid_get_bdevs`

4
doc/jsonrpc.md
View File

@ -5330,7 +5330,7 @@ Example response:
}
~~~
## construct_raid_bdev {#rpc_construct_raid_bdev}
## bdev_raid_create {#rpc_bdev_raid_create}
Constructs new RAID bdev.
@ -5351,7 +5351,7 @@ Example request:
~~~
{
"jsonrpc": "2.0",
"method": "construct_raid_bdev",
"method": "bdev_raid_create",
"id": 1,
"params": {
"name": "Raid0",

2
module/bdev/raid/bdev_raid.c
View File

@ -987,7 +987,7 @@ raid_bdev_write_config_json(struct spdk_bdev *bdev, struct spdk_json_write_ctx *
spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "construct_raid_bdev");
spdk_json_write_named_string(w, "method", "bdev_raid_create");
spdk_json_write_named_object_begin(w, "params");
spdk_json_write_named_string(w, "name", bdev->name);

49
module/bdev/raid/bdev_raid_rpc.c
View File

@ -143,9 +143,9 @@ SPDK_RPC_REGISTER("bdev_raid_get_bdevs", spdk_rpc_bdev_raid_get_bdevs, SPDK_RPC_
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_get_bdevs, get_raid_bdevs)
/*
* Base bdevs in RPC construct_raid
* Base bdevs in RPC bdev_raid_create
*/
struct rpc_construct_raid_base_bdevs {
struct rpc_bdev_raid_create_base_bdevs {
/* Number of base bdevs */
size_t num_base_bdevs;
@ -154,9 +154,9 @@ struct rpc_construct_raid_base_bdevs {
};
/*
* Input structure for RPC construct_raid
* Input structure for RPC rpc_bdev_raid_create
*/
struct rpc_construct_raid_bdev {
struct rpc_bdev_raid_create {
/* Raid bdev name */
char *name;
@ -168,19 +168,19 @@ struct rpc_construct_raid_bdev {
uint8_t raid_level;
/* Base bdevs information */
struct rpc_construct_raid_base_bdevs base_bdevs;
struct rpc_bdev_raid_create_base_bdevs base_bdevs;
};
/*
* brief:
* free_rpc_construct_raid_bdev function is to free RPC construct_raid_bdev related parameters
* free_rpc_bdev_raid_create function is to free RPC bdev_raid_create related parameters
* params:
* req - pointer to RPC request
* returns:
* none
*/
static void
free_rpc_construct_raid_bdev(struct rpc_construct_raid_bdev *req)
free_rpc_bdev_raid_create(struct rpc_bdev_raid_create *req)
{
free(req->name);
for (size_t i = 0; i < req->base_bdevs.num_base_bdevs; i++) {
@ -189,31 +189,31 @@ free_rpc_construct_raid_bdev(struct rpc_construct_raid_bdev *req)
}
/*
* Decoder function for RPC construct_raid_bdev to decode base bdevs list
* Decoder function for RPC bdev_raid_create to decode base bdevs list
*/
static int
decode_base_bdevs(const struct spdk_json_val *val, void *out)
{
struct rpc_construct_raid_base_bdevs *base_bdevs = out;
struct rpc_bdev_raid_create_base_bdevs *base_bdevs = out;
return spdk_json_decode_array(val, spdk_json_decode_string, base_bdevs->base_bdevs,
RPC_MAX_BASE_BDEVS, &base_bdevs->num_base_bdevs, sizeof(char *));
}
/*
* Decoder object for RPC construct_raid
* Decoder object for RPC bdev_raid_create
*/
/* Note: strip_size is deprecated, one of the two options must be specified but not both. */
static const struct spdk_json_object_decoder rpc_construct_raid_bdev_decoders[] = {
{"name", offsetof(struct rpc_construct_raid_bdev, name), spdk_json_decode_string},
{"strip_size", offsetof(struct rpc_construct_raid_bdev, strip_size), spdk_json_decode_uint32, true},
{"strip_size_kb", offsetof(struct rpc_construct_raid_bdev, strip_size_kb), spdk_json_decode_uint32, true},
{"raid_level", offsetof(struct rpc_construct_raid_bdev, raid_level), spdk_json_decode_uint32},
{"base_bdevs", offsetof(struct rpc_construct_raid_bdev, base_bdevs), decode_base_bdevs},
static const struct spdk_json_object_decoder rpc_bdev_raid_create_decoders[] = {
{"name", offsetof(struct rpc_bdev_raid_create, name), spdk_json_decode_string},
{"strip_size", offsetof(struct rpc_bdev_raid_create, strip_size), spdk_json_decode_uint32, true},
{"strip_size_kb", offsetof(struct rpc_bdev_raid_create, strip_size_kb), spdk_json_decode_uint32, true},
{"raid_level", offsetof(struct rpc_bdev_raid_create, raid_level), spdk_json_decode_uint32},
{"base_bdevs", offsetof(struct rpc_bdev_raid_create, base_bdevs), decode_base_bdevs},
};
/*
* brief:
* spdk_rpc_construct_raid_bdev function is the RPC for construct_raids. It takes
* spdk_rpc_bdev_raid_create function is the RPC for creating RAID bdevs. It takes
* input as raid bdev name, raid level, strip size in KB and list of base bdev names.
* params:
* requuest - pointer to json rpc request
@ -222,16 +222,16 @@ static const struct spdk_json_object_decoder rpc_construct_raid_bdev_decoders[]
* none
*/
static void
spdk_rpc_construct_raid_bdev(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
spdk_rpc_bdev_raid_create(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_construct_raid_bdev req = {};
struct rpc_bdev_raid_create req = {};
struct spdk_json_write_ctx *w;
struct raid_bdev_config *raid_cfg;
int rc;
if (spdk_json_decode_object(params, rpc_construct_raid_bdev_decoders,
SPDK_COUNTOF(rpc_construct_raid_bdev_decoders),
if (spdk_json_decode_object(params, rpc_bdev_raid_create_decoders,
SPDK_COUNTOF(rpc_bdev_raid_create_decoders),
&req)) {
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
"spdk_json_decode_object failed");
@ -294,9 +294,10 @@ spdk_rpc_construct_raid_bdev(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w);
cleanup:
free_rpc_construct_raid_bdev(&req);
free_rpc_bdev_raid_create(&req);
}
SPDK_RPC_REGISTER("construct_raid_bdev", spdk_rpc_construct_raid_bdev, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER("bdev_raid_create", spdk_rpc_bdev_raid_create, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_raid_create, construct_raid_bdev)
/*
* Input structure for RPC destroy_raid

19
scripts/rpc.py
View File

@ -1334,24 +1334,25 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.add_argument('category', help='all or online or configuring or offline')
p.set_defaults(func=bdev_raid_get_bdevs)
def construct_raid_bdev(args):
def bdev_raid_create(args):
base_bdevs = []
for u in args.base_bdevs.strip().split(" "):
base_bdevs.append(u)
rpc.bdev.construct_raid_bdev(args.client,
name=args.name,
strip_size=args.strip_size,
strip_size_kb=args.strip_size_kb,
raid_level=args.raid_level,
base_bdevs=base_bdevs)
p = subparsers.add_parser('construct_raid_bdev', help='Construct new raid bdev')
rpc.bdev.bdev_raid_create(args.client,
name=args.name,
strip_size=args.strip_size,
strip_size_kb=args.strip_size_kb,
raid_level=args.raid_level,
base_bdevs=base_bdevs)
p = subparsers.add_parser('bdev_raid_create', aliases=['construct_raid_bdev'],
help='Create new raid bdev')
p.add_argument('-n', '--name', help='raid bdev name', required=True)
p.add_argument('-s', '--strip-size', help='strip size in KB (deprecated)', type=int)
p.add_argument('-z', '--strip-size_kb', help='strip size in KB', type=int)
p.add_argument('-r', '--raid-level', help='raid level, only raid level 0 is supported', type=int, required=True)
p.add_argument('-b', '--base-bdevs', help='base bdevs name, whitespace separated list in quotes', required=True)
p.set_defaults(func=construct_raid_bdev)
p.set_defaults(func=bdev_raid_create)
def destroy_raid_bdev(args):
rpc.bdev.destroy_raid_bdev(args.client,

7
scripts/rpc/bdev.py
View File

@ -249,8 +249,9 @@ def bdev_raid_get_bdevs(client, category):
return client.call('bdev_raid_get_bdevs', params)
def construct_raid_bdev(client, name, raid_level, base_bdevs, strip_size=None, strip_size_kb=None):
"""Construct raid bdev. Either strip size arg will work but one is required.
@deprecated_alias('construct_raid_bdev')
def bdev_raid_create(client, name, raid_level, base_bdevs, strip_size=None, strip_size_kb=None):
"""Create raid bdev. Either strip size arg will work but one is required.
Args:
name: user defined raid bdev name
@ -270,7 +271,7 @@ def construct_raid_bdev(client, name, raid_level, base_bdevs, strip_size=None, s
if strip_size_kb:
params['strip_size_kb'] = strip_size_kb
return client.call('construct_raid_bdev', params)
return client.call('bdev_raid_create', params)
def destroy_raid_bdev(client, name):

8
scripts/spdkcli/ui_node.py
View File

@ -846,10 +846,10 @@ class UIRaidBdev(UIBdev):
raid_level = self.ui_eval_param(raid_level, "number", None)
strip_size_kb = self.ui_eval_param(strip_size_kb, "number", None)
ret_name = self.get_root().construct_raid_bdev(name=name,
raid_level=raid_level,
base_bdevs=base_bdevs_array,
strip_size_kb=strip_size_kb)
ret_name = self.get_root().bdev_raid_create(name=name,
raid_level=raid_level,
base_bdevs=base_bdevs_array,
strip_size_kb=strip_size_kb)
self.shell.log.info(ret_name)
def ui_command_delete(self, name):

4
scripts/spdkcli/ui_root.py
View File

@ -250,8 +250,8 @@ class UIRoot(UINode):
return response
@verbose
def construct_raid_bdev(self, **kwargs):
rpc.bdev.construct_raid_bdev(self.client, **kwargs)
def bdev_raid_create(self, **kwargs):
rpc.bdev.bdev_raid_create(self.client, **kwargs)
@verbose
def destroy_raid_bdev(self, **kwargs):

2
test/bdev/bdev_raid.sh
View File

@ -63,7 +63,7 @@ function configure_raid_bdev() {
echo bdev_malloc_create 32 512 -b Base_1 >> $testdir/rpcs.txt
echo bdev_malloc_create 32 512 -b Base_2 >> $testdir/rpcs.txt
echo construct_raid_bdev -z 64 -r 0 -b \"Base_1 Base_2\" -n raid0 >> $testdir/rpcs.txt
echo bdev_raid_create -z 64 -r 0 -b \"Base_1 Base_2\" -n raid0 >> $testdir/rpcs.txt
$rpc_py < $testdir/rpcs.txt
rm -rf $testdir/rpcs.txt

2
test/iscsi_tgt/fio/fio.sh
View File

@ -83,7 +83,7 @@ $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
# Create a RAID-0 bdev from two malloc bdevs
malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
$rpc_py bdev_raid_create -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
bdev=$( $rpc_py bdev_malloc_create 1024 512 )
# "raid0:0" ==> use raid0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2

2
test/iscsi_tgt/lvol/iscsi_lvol.sh
View File

@ -50,7 +50,7 @@ for i in $(seq 1 $NUM_LVS); do
# construct RAID bdev and put its name in $bdev
malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
$rpc_py bdev_raid_create -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
bdev="raid0"
else
# construct malloc bdev and put its name in $bdev

2
test/nvmf/target/fio.sh
View File

@ -21,7 +21,7 @@ malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# Create a RAID-0 bdev from two malloc bdevs
raid_malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
raid_malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$raid_malloc_bdevs"
$rpc_py bdev_raid_create -n raid0 -z 64 -r 0 -b "$raid_malloc_bdevs"
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001
for malloc_bdev in $malloc_bdevs; do

2
test/nvmf/target/nvmf_lvol.sh
View File

@ -29,7 +29,7 @@ $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
# Construct a RAID volume for the logical volume store
base_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
base_bdevs+=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs"
$rpc_py bdev_raid_create -n raid0 -z 64 -r 0 -b "$base_bdevs"
# Create the logical volume store on the RAID volume
lvs=$($rpc_py bdev_lvol_create_lvstore raid0 lvs)

186
test/unit/lib/bdev/bdev_raid.c/bdev_raid_ut.c
View File

@ -86,7 +86,7 @@ uint8_t g_rpc_err;
char *g_get_raids_output[MAX_RAIDS];
uint32_t g_get_raids_count;
uint8_t g_json_decode_obj_err;
uint8_t g_json_decode_obj_construct;
uint8_t g_json_decode_obj_create;
uint8_t g_config_level_create = 0;
uint8_t g_test_multi_raids;
struct raid_io_ranges g_io_ranges[MAX_TEST_IO_RANGE];
@ -187,7 +187,7 @@ set_globals(void)
g_rpc_req = NULL;
g_rpc_req_size = 0;
g_json_decode_obj_err = 0;
g_json_decode_obj_construct = 0;
g_json_decode_obj_create = 0;
g_lba_offset = 0;
}
@ -381,7 +381,7 @@ spdk_sprintf_alloc(const char *format, ...)
int spdk_json_write_named_uint32(struct spdk_json_write_ctx *w, const char *name, uint32_t val)
{
struct rpc_construct_raid_bdev *req = g_rpc_req;
struct rpc_bdev_raid_create *req = g_rpc_req;
if (strcmp(name, "strip_size_kb") == 0) {
CU_ASSERT(req->strip_size_kb == val);
} else if (strcmp(name, "blocklen_shift") == 0) {
@ -479,7 +479,7 @@ spdk_conf_section_match_prefix(const struct spdk_conf_section *sp, const char *n
char *
spdk_conf_section_get_val(struct spdk_conf_section *sp, const char *key)
{
struct rpc_construct_raid_bdev *req = g_rpc_req;
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "Name") == 0) {
@ -493,7 +493,7 @@ spdk_conf_section_get_val(struct spdk_conf_section *sp, const char *key)
int
spdk_conf_section_get_intval(struct spdk_conf_section *sp, const char *key)
{
struct rpc_construct_raid_bdev *req = g_rpc_req;
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "StripSize") == 0) {
@ -511,7 +511,7 @@ spdk_conf_section_get_intval(struct spdk_conf_section *sp, const char *key)
char *
spdk_conf_section_get_nmval(struct spdk_conf_section *sp, const char *key, int idx1, int idx2)
{
struct rpc_construct_raid_bdev *req = g_rpc_req;
struct rpc_bdev_raid_create *req = g_rpc_req;
if (g_config_level_create) {
if (strcmp(key, "Devices") == 0) {
@ -541,12 +541,12 @@ spdk_json_decode_object(const struct spdk_json_val *values,
const struct spdk_json_object_decoder *decoders, size_t num_decoders,
void *out)
{
struct rpc_construct_raid_bdev *req, *_out;
struct rpc_bdev_raid_create *req, *_out;
size_t i;
if (g_json_decode_obj_err) {
return -1;
} else if (g_json_decode_obj_construct) {
} else if (g_json_decode_obj_create) {
req = g_rpc_req;
_out = out;
@ -886,7 +886,7 @@ verify_raid_bdev_present(const char *name, bool presence)
}
}
static void
verify_raid_config(struct rpc_construct_raid_bdev *r, bool presence)
verify_raid_config(struct rpc_bdev_raid_create *r, bool presence)
{
struct raid_bdev_config *raid_cfg = NULL;
uint8_t i;
@ -920,7 +920,7 @@ verify_raid_config(struct rpc_construct_raid_bdev *r, bool presence)
}
static void
verify_raid_bdev(struct rpc_construct_raid_bdev *r, bool presence, uint32_t raid_state)
verify_raid_bdev(struct rpc_bdev_raid_create *r, bool presence, uint32_t raid_state)
{
struct raid_bdev *pbdev;
uint8_t i;
@ -1014,7 +1014,7 @@ verify_raid_bdev(struct rpc_construct_raid_bdev *r, bool presence, uint32_t raid
}
static void
verify_get_raids(struct rpc_construct_raid_bdev *construct_req,
verify_get_raids(struct rpc_bdev_raid_create *construct_req,
uint8_t g_max_raids,
char **g_get_raids_output, uint32_t g_get_raids_count)
{
@ -1057,7 +1057,7 @@ create_base_bdevs(uint32_t bbdev_start_idx)
}
static void
create_test_req(struct rpc_construct_raid_bdev *r, const char *raid_name,
create_test_req(struct rpc_bdev_raid_create *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev)
{
uint8_t i;
@ -1082,22 +1082,22 @@ create_test_req(struct rpc_construct_raid_bdev *r, const char *raid_name,
}
static void
create_construct_req(struct rpc_construct_raid_bdev *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev,
uint8_t json_decode_obj_err)
create_raid_bdev_create_req(struct rpc_bdev_raid_create *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev,
uint8_t json_decode_obj_err)
{
create_test_req(r, raid_name, bbdev_start_idx, create_base_bdev);
g_rpc_err = 0;
g_json_decode_obj_construct = 1;
g_json_decode_obj_create = 1;
g_json_decode_obj_err = json_decode_obj_err;
g_config_level_create = 0;
g_test_multi_raids = 0;
}
static void
create_construct_config(struct rpc_construct_raid_bdev *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev)
create_raid_bdev_create_config(struct rpc_bdev_raid_create *r, const char *raid_name,
uint8_t bbdev_start_idx, bool create_base_bdev)
{
create_test_req(r, raid_name, bbdev_start_idx, create_base_bdev);
@ -1106,7 +1106,7 @@ create_construct_config(struct rpc_construct_raid_bdev *r, const char *raid_name
}
static void
free_test_req(struct rpc_construct_raid_bdev *r)
free_test_req(struct rpc_bdev_raid_create *r)
{
uint8_t i;
@ -1126,7 +1126,7 @@ create_destroy_req(struct rpc_destroy_raid_bdev *r, const char *raid_name,
g_rpc_req = r;
g_rpc_req_size = sizeof(*r);
g_rpc_err = 0;
g_json_decode_obj_construct = 0;
g_json_decode_obj_create = 0;
g_json_decode_obj_err = json_decode_obj_err;
g_config_level_create = 0;
g_test_multi_raids = 0;
@ -1142,7 +1142,7 @@ create_get_raids_req(struct rpc_bdev_raid_get_bdevs *r, const char *category,
g_rpc_req = r;
g_rpc_req_size = sizeof(*r);
g_rpc_err = 0;
g_json_decode_obj_construct = 0;
g_json_decode_obj_create = 0;
g_json_decode_obj_err = json_decode_obj_err;
g_config_level_create = 0;
g_test_multi_raids = 1;
@ -1150,9 +1150,9 @@ create_get_raids_req(struct rpc_bdev_raid_get_bdevs *r, const char *category,
}
static void
test_construct_raid(void)
test_create_raid(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
set_globals();
@ -1160,8 +1160,8 @@ test_construct_raid(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1178,7 +1178,7 @@ test_construct_raid(void)
static void
test_destroy_raid(void)
{
struct rpc_construct_raid_bdev construct_req;
struct rpc_bdev_raid_create construct_req;
struct rpc_destroy_raid_bdev destroy_req;
set_globals();
@ -1186,8 +1186,8 @@ test_destroy_raid(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&construct_req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&construct_req, true);
verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE);
@ -1205,9 +1205,9 @@ test_destroy_raid(void)
}
static void
test_construct_raid_invalid_args(void)
test_create_raid_invalid_args(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev_config *raid_cfg;
@ -1216,63 +1216,63 @@ test_construct_raid_invalid_args(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
req.raid_level = 1;
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, false, 1);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, false, 1);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, false, 0);
create_raid_bdev_create_req(&req, "raid1", 0, false, 0);
req.strip_size_kb = 1231;
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, false, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, false, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
free_test_req(&req);
create_construct_req(&req, "raid1", 0, false, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, false, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
create_construct_req(&req, "raid2", 0, false, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid2", 0, false, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
verify_raid_config_present("raid2", false);
verify_raid_bdev_present("raid2", false);
create_construct_req(&req, "raid2", g_max_base_drives, true, 0);
create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0);
free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]);
req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme0n1");
SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL);
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 1);
free_test_req(&req);
verify_raid_config_present("raid2", false);
verify_raid_bdev_present("raid2", false);
create_construct_req(&req, "raid2", g_max_base_drives, true, 0);
create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, true, 0);
free(req.base_bdevs.base_bdevs[g_max_base_drives - 1]);
req.base_bdevs.base_bdevs[g_max_base_drives - 1] = strdup("Nvme100000n1");
SPDK_CU_ASSERT_FATAL(req.base_bdevs.base_bdevs[g_max_base_drives - 1] != NULL);
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
free_test_req(&req);
verify_raid_config_present("raid2", true);
@ -1282,8 +1282,8 @@ test_construct_raid_invalid_args(void)
check_and_remove_raid_bdev(raid_cfg);
raid_bdev_config_cleanup(raid_cfg);
create_construct_req(&req, "raid2", g_max_base_drives, false, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid2", g_max_base_drives, false, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
free_test_req(&req);
verify_raid_config_present("raid2", true);
@ -1303,7 +1303,7 @@ test_construct_raid_invalid_args(void)
static void
test_destroy_raid_invalid_args(void)
{
struct rpc_construct_raid_bdev construct_req;
struct rpc_bdev_raid_create construct_req;
struct rpc_destroy_raid_bdev destroy_req;
set_globals();
@ -1311,8 +1311,8 @@ test_destroy_raid_invalid_args(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&construct_req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&construct_req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&construct_req, true);
verify_raid_bdev(&construct_req, true, RAID_BDEV_STATE_ONLINE);
@ -1343,7 +1343,7 @@ test_destroy_raid_invalid_args(void)
static void
test_io_channel(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct raid_bdev_io_channel *ch_ctx;
@ -1352,10 +1352,10 @@ test_io_channel(void)
set_globals();
CU_ASSERT(raid_bdev_init() == 0);
create_construct_req(&req, "raid1", 0, true, 0);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1392,7 +1392,7 @@ test_io_channel(void)
static void
test_write_io(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct spdk_io_channel *ch;
@ -1407,10 +1407,10 @@ test_write_io(void)
set_globals();
CU_ASSERT(raid_bdev_init() == 0);
create_construct_req(&req, "raid1", 0, true, 0);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1470,7 +1470,7 @@ test_write_io(void)
static void
test_read_io(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct spdk_io_channel *ch;
@ -1487,8 +1487,8 @@ test_read_io(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1624,7 +1624,7 @@ raid_bdev_io_generate(void)
static void
test_unmap_io(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct spdk_io_channel *ch;
@ -1640,8 +1640,8 @@ test_unmap_io(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1698,7 +1698,7 @@ test_unmap_io(void)
static void
test_io_failure(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct spdk_io_channel *ch;
@ -1714,8 +1714,8 @@ test_io_failure(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1786,7 +1786,7 @@ test_io_failure(void)
static void
test_reset_io(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
struct spdk_io_channel *ch;
@ -1799,8 +1799,8 @@ test_reset_io(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&req, true);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -1854,7 +1854,7 @@ test_reset_io(void)
static void
test_multi_raid_no_io(void)
{
struct rpc_construct_raid_bdev *construct_req;
struct rpc_bdev_raid_create *construct_req;
struct rpc_destroy_raid_bdev destroy_req;
struct rpc_bdev_raid_get_bdevs get_raids_req;
uint8_t i;
@ -1862,16 +1862,16 @@ test_multi_raid_no_io(void)
uint8_t bbdev_idx = 0;
set_globals();
construct_req = calloc(MAX_RAIDS, sizeof(struct rpc_construct_raid_bdev));
construct_req = calloc(MAX_RAIDS, sizeof(struct rpc_bdev_raid_create));
SPDK_CU_ASSERT_FATAL(construct_req != NULL);
CU_ASSERT(raid_bdev_init() == 0);
for (i = 0; i < g_max_raids; i++) {
snprintf(name, 16, "%s%u", "raid", i);
verify_raid_config_present(name, false);
verify_raid_bdev_present(name, false);
create_construct_req(&construct_req[i], name, bbdev_idx, true, 0);
create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0);
bbdev_idx += g_max_base_drives;
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&construct_req[i], true);
verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE);
@ -1944,7 +1944,7 @@ test_multi_raid_no_io(void)
static void
test_multi_raid_with_io(void)
{
struct rpc_construct_raid_bdev *construct_req;
struct rpc_bdev_raid_create *construct_req;
struct rpc_destroy_raid_bdev destroy_req;
uint8_t i, j;
char name[16];
@ -1960,7 +1960,7 @@ test_multi_raid_with_io(void)
struct spdk_bdev_channel *ch_b_ctx;
set_globals();
construct_req = calloc(g_max_raids, sizeof(struct rpc_construct_raid_bdev));
construct_req = calloc(g_max_raids, sizeof(struct rpc_bdev_raid_create));
SPDK_CU_ASSERT_FATAL(construct_req != NULL);
CU_ASSERT(raid_bdev_init() == 0);
ch = calloc(g_max_raids, sizeof(struct spdk_io_channel) + sizeof(struct raid_bdev_io_channel));
@ -1975,9 +1975,9 @@ test_multi_raid_with_io(void)
snprintf(name, 16, "%s%u", "raid", i);
verify_raid_config_present(name, false);
verify_raid_bdev_present(name, false);
create_construct_req(&construct_req[i], name, bbdev_idx, true, 0);
create_raid_bdev_create_req(&construct_req[i], name, bbdev_idx, true, 0);
bbdev_idx += g_max_base_drives;
spdk_rpc_construct_raid_bdev(NULL, NULL);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_config(&construct_req[i], true);
verify_raid_bdev(&construct_req[i], true, RAID_BDEV_STATE_ONLINE);
@ -2060,7 +2060,7 @@ test_io_type_supported(void)
static void
test_create_raid_from_config(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct spdk_bdev *bdev;
struct rpc_destroy_raid_bdev destroy_req;
bool can_claim;
@ -2068,7 +2068,7 @@ test_create_raid_from_config(void)
uint8_t base_bdev_slot;
set_globals();
create_construct_config(&req, "raid1", 0, true);
create_raid_bdev_create_config(&req, "raid1", 0, true);
CU_ASSERT(raid_bdev_init() == 0);
verify_raid_config_present("raid1", true);
@ -2099,11 +2099,11 @@ test_create_raid_from_config(void)
static void
test_create_raid_from_config_invalid_params(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
set_globals();
create_construct_config(&req, "raid1", 0, true);
create_raid_bdev_create_config(&req, "raid1", 0, true);
free(req.name);
req.name = NULL;
CU_ASSERT(raid_bdev_init() != 0);
@ -2111,28 +2111,28 @@ test_create_raid_from_config_invalid_params(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.strip_size_kb = 1234;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.raid_level = 1;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.raid_level = 1;
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.base_bdevs.num_base_bdevs++;
CU_ASSERT(raid_bdev_init() != 0);
req.base_bdevs.num_base_bdevs--;
@ -2140,7 +2140,7 @@ test_create_raid_from_config_invalid_params(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
req.base_bdevs.num_base_bdevs--;
CU_ASSERT(raid_bdev_init() != 0);
req.base_bdevs.num_base_bdevs++;
@ -2149,7 +2149,7 @@ test_create_raid_from_config_invalid_params(void)
verify_raid_bdev_present("raid1", false);
if (g_max_base_drives > 1) {
create_construct_config(&req, "raid1", 0, false);
create_raid_bdev_create_config(&req, "raid1", 0, false);
snprintf(req.base_bdevs.base_bdevs[g_max_base_drives - 1], 15, "%s", "Nvme0n1");
CU_ASSERT(raid_bdev_init() != 0);
free_test_req(&req);
@ -2165,7 +2165,7 @@ test_create_raid_from_config_invalid_params(void)
static void
test_raid_json_dump_info(void)
{
struct rpc_construct_raid_bdev req;
struct rpc_bdev_raid_create req;
struct rpc_destroy_raid_bdev destroy_req;
struct raid_bdev *pbdev;
@ -2174,8 +2174,8 @@ test_raid_json_dump_info(void)
verify_raid_config_present("raid1", false);
verify_raid_bdev_present("raid1", false);
create_construct_req(&req, "raid1", 0, true, 0);
spdk_rpc_construct_raid_bdev(NULL, NULL);
create_raid_bdev_create_req(&req, "raid1", 0, true, 0);
spdk_rpc_bdev_raid_create(NULL, NULL);
CU_ASSERT(g_rpc_err == 0);
verify_raid_bdev(&req, true, RAID_BDEV_STATE_ONLINE);
@ -2223,10 +2223,10 @@ int main(int argc, char **argv)
}
if (
CU_add_test(suite, "test_construct_raid", test_construct_raid) == NULL ||
CU_add_test(suite, "test_create_raid", test_create_raid) == NULL ||
CU_add_test(suite, "test_destroy_raid", test_destroy_raid) == NULL ||
CU_add_test(suite, "test_construct_raid_invalid_args",
test_construct_raid_invalid_args) == NULL ||
CU_add_test(suite, "test_create_raid_invalid_args",
test_create_raid_invalid_args) == NULL ||
CU_add_test(suite, "test_destroy_raid_invalid_args",
test_destroy_raid_invalid_args) == NULL ||
CU_add_test(suite, "test_io_channel", test_io_channel) == NULL ||

6
test/vhost/fiotest/conf.json
View File

@ -78,7 +78,7 @@
"method": "bdev_malloc_create"
},
{
"method": "construct_raid_bdev",
"method": "bdev_raid_create",
"params": {
"name": "RaidBdev0",
"strip_size": 128,
@ -90,7 +90,7 @@
}
},
{
"method": "construct_raid_bdev",
"method": "bdev_raid_create",
"params": {
"name": "RaidBdev1",
"strip_size": 128,
@ -102,7 +102,7 @@
}
},
{
"method": "construct_raid_bdev",
"method": "bdev_raid_create",
"params": {
"name": "RaidBdev2",
"strip_size": 128,