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

bdev/nvme: support switch to another io path after a number of IOs

Browse Source 
Support to specify rr_min_io for multipath round-robin policy,
which makes I/O switches to another io path after rr_min_io I/Os are
rounted to current io path.

Change-Id: I09f0d8d24271c0178ff816fa63ce8576b6e8ae47
Signed-off-by: Richael Zhuang <richael.zhuang@arm.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/15445
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@nvidia.com>
Reviewed-by: Shuhei Matsumoto <smatsumoto@nvidia.com>
This commit is contained in:
Richael Zhuang 2022-10-31 15:13:30 +08:00 committed by Jim Harris
parent 6fa3497b69
commit 2f500a23fb
8 changed files with 77 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG.md
View File

@ -94,6 +94,10 @@ Changed `bdev_raid_get_bdevs` RPC output format to include raid_bdev details.
Added `selector` parameter to bdev_nvme_set_multipath_policy RPC to set path selector for multipath. Added `selector` parameter to bdev_nvme_set_multipath_policy RPC to set path selector for multipath.
Option `round_robin` and `queue_depth` are available. Option `round_robin` and `queue_depth` are available.
Added `rr_min_io` option to RPC bdev_nvme_set_multipath_policy. It switches I/O to
another path after rr_min_io I/Os are routed to current io path for the round-robin
path selector.
### bdevperf ### bdevperf
Promoted the application to example to match similar programs: fio_plugin and perf. Promoted the application to example to match similar programs: fio_plugin and perf.

1
doc/jsonrpc.md
View File

@ -4145,6 +4145,7 @@ Name | Optional | Type | Description
name | Required | string | Name of the NVMe bdev name | Required | string | Name of the NVMe bdev
policy | Required | string | Multipath policy: active_active or active_passive policy | Required | string | Multipath policy: active_active or active_passive
selector | Optional | string | Multipath selector: round_robin or queue_depth, used in active-active mode. Default is round_robin selector | Optional | string | Multipath selector: round_robin or queue_depth, used in active-active mode. Default is round_robin
rr_min_io | Optional | number | Number of I/Os routed to current io path before switching to another for round-robin selector. The min value is 1.
#### Example #### Example

36
module/bdev/nvme/bdev_nvme.c
View File

@ -557,6 +557,7 @@ static void
bdev_nvme_clear_current_io_path(struct nvme_bdev_channel *nbdev_ch) bdev_nvme_clear_current_io_path(struct nvme_bdev_channel *nbdev_ch)
{ {
nbdev_ch->current_io_path = NULL; nbdev_ch->current_io_path = NULL;
nbdev_ch->rr_counter = 0;
} }
static struct nvme_io_path * static struct nvme_io_path *
@ -662,6 +663,7 @@ bdev_nvme_create_bdev_channel_cb(void *io_device, void *ctx_buf)
nbdev_ch->mp_policy = nbdev->mp_policy; nbdev_ch->mp_policy = nbdev->mp_policy;
nbdev_ch->mp_selector = nbdev->mp_selector; nbdev_ch->mp_selector = nbdev->mp_selector;
nbdev_ch->rr_min_io = nbdev->rr_min_io;
TAILQ_FOREACH(nvme_ns, &nbdev->nvme_ns_list, tailq) { TAILQ_FOREACH(nvme_ns, &nbdev->nvme_ns_list, tailq) {
rc = _bdev_nvme_add_io_path(nbdev_ch, nvme_ns); rc = _bdev_nvme_add_io_path(nbdev_ch, nvme_ns);
@ -928,9 +930,15 @@ _bdev_nvme_find_io_path_min_qd(struct nvme_bdev_channel *nbdev_ch)
static inline struct nvme_io_path * static inline struct nvme_io_path *
bdev_nvme_find_io_path(struct nvme_bdev_channel *nbdev_ch) bdev_nvme_find_io_path(struct nvme_bdev_channel *nbdev_ch)
{ {
if (spdk_likely(nbdev_ch->current_io_path != NULL && if (spdk_likely(nbdev_ch->current_io_path != NULL)) {
nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE)) { if (nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE) {
return nbdev_ch->current_io_path; return nbdev_ch->current_io_path;
} else if (nbdev_ch->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN) {
if (++nbdev_ch->rr_counter < nbdev_ch->rr_min_io) {
return nbdev_ch->current_io_path;
}
nbdev_ch->rr_counter = 0;
}
} }
if (nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE || if (nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE ||
@ -3359,6 +3367,7 @@ nvme_bdev_create(struct nvme_ctrlr *nvme_ctrlr, struct nvme_ns *nvme_ns)
bdev->ref = 1; bdev->ref = 1;
bdev->mp_policy = BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE; bdev->mp_policy = BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE;
bdev->mp_selector = BDEV_NVME_MP_SELECTOR_ROUND_ROBIN; bdev->mp_selector = BDEV_NVME_MP_SELECTOR_ROUND_ROBIN;
bdev->rr_min_io = UINT32_MAX;
TAILQ_INIT(&bdev->nvme_ns_list); TAILQ_INIT(&bdev->nvme_ns_list);
TAILQ_INSERT_TAIL(&bdev->nvme_ns_list, nvme_ns, tailq); TAILQ_INSERT_TAIL(&bdev->nvme_ns_list, nvme_ns, tailq);
bdev->opal = nvme_ctrlr->opal_dev != NULL; bdev->opal = nvme_ctrlr->opal_dev != NULL;
@ -4169,6 +4178,7 @@ _bdev_nvme_set_multipath_policy(struct spdk_io_channel_iter *i)
nbdev_ch->mp_policy = nbdev->mp_policy; nbdev_ch->mp_policy = nbdev->mp_policy;
nbdev_ch->mp_selector = nbdev->mp_selector; nbdev_ch->mp_selector = nbdev->mp_selector;
nbdev_ch->rr_min_io = nbdev->rr_min_io;
bdev_nvme_clear_current_io_path(nbdev_ch); bdev_nvme_clear_current_io_path(nbdev_ch);
spdk_for_each_channel_continue(i, 0); spdk_for_each_channel_continue(i, 0);
@ -4176,7 +4186,8 @@ _bdev_nvme_set_multipath_policy(struct spdk_io_channel_iter *i)
void void
bdev_nvme_set_multipath_policy(const char *name, enum bdev_nvme_multipath_policy policy, bdev_nvme_set_multipath_policy(const char *name, enum bdev_nvme_multipath_policy policy,
enum bdev_nvme_multipath_selector selector, bdev_nvme_set_multipath_policy_cb cb_fn, void *cb_arg) enum bdev_nvme_multipath_selector selector, uint32_t rr_min_io,
bdev_nvme_set_multipath_policy_cb cb_fn, void *cb_arg)
{ {
struct bdev_nvme_set_multipath_policy_ctx *ctx; struct bdev_nvme_set_multipath_policy_ctx *ctx;
struct spdk_bdev *bdev; struct spdk_bdev *bdev;
@ -4185,11 +4196,23 @@ bdev_nvme_set_multipath_policy(const char *name, enum bdev_nvme_multipath_policy
assert(cb_fn != NULL); assert(cb_fn != NULL);
if (policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE && selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN) {
if (rr_min_io == UINT32_MAX) {
rr_min_io = 1;
} else if (rr_min_io == 0) {
rc = -EINVAL;
goto exit;
}
} else if (rr_min_io != UINT32_MAX) {
rc = -EINVAL;
goto exit;
}
ctx = calloc(1, sizeof(*ctx)); ctx = calloc(1, sizeof(*ctx));
if (ctx == NULL) { if (ctx == NULL) {
SPDK_ERRLOG("Failed to alloc context.\n"); SPDK_ERRLOG("Failed to alloc context.\n");
rc = -ENOMEM; rc = -ENOMEM;
goto err_alloc; goto exit;
} }
ctx->cb_fn = cb_fn; ctx->cb_fn = cb_fn;
@ -4213,6 +4236,7 @@ bdev_nvme_set_multipath_policy(const char *name, enum bdev_nvme_multipath_policy
pthread_mutex_lock(&nbdev->mutex); pthread_mutex_lock(&nbdev->mutex);
nbdev->mp_policy = policy; nbdev->mp_policy = policy;
nbdev->mp_selector = selector; nbdev->mp_selector = selector;
nbdev->rr_min_io = rr_min_io;
pthread_mutex_unlock(&nbdev->mutex); pthread_mutex_unlock(&nbdev->mutex);
spdk_for_each_channel(nbdev, spdk_for_each_channel(nbdev,
@ -4225,7 +4249,7 @@ err_module:
spdk_bdev_close(ctx->desc); spdk_bdev_close(ctx->desc);
err_open: err_open:
free(ctx); free(ctx);
err_alloc: exit:
cb_fn(cb_arg, rc); cb_fn(cb_arg, rc);
} }

5
module/bdev/nvme/bdev_nvme.h
View File

@ -164,6 +164,7 @@ struct nvme_bdev {
int ref; int ref;
enum bdev_nvme_multipath_policy mp_policy; enum bdev_nvme_multipath_policy mp_policy;
enum bdev_nvme_multipath_selector mp_selector; enum bdev_nvme_multipath_selector mp_selector;
uint32_t rr_min_io;
TAILQ_HEAD(, nvme_ns) nvme_ns_list; TAILQ_HEAD(, nvme_ns) nvme_ns_list;
bool opal; bool opal;
TAILQ_ENTRY(nvme_bdev) tailq; TAILQ_ENTRY(nvme_bdev) tailq;
@ -203,6 +204,8 @@ struct nvme_bdev_channel {
struct nvme_io_path *current_io_path; struct nvme_io_path *current_io_path;
enum bdev_nvme_multipath_policy mp_policy; enum bdev_nvme_multipath_policy mp_policy;
enum bdev_nvme_multipath_selector mp_selector; enum bdev_nvme_multipath_selector mp_selector;
uint32_t rr_min_io;
uint32_t rr_counter;
STAILQ_HEAD(, nvme_io_path) io_path_list; STAILQ_HEAD(, nvme_io_path) io_path_list;
TAILQ_HEAD(retry_io_head, spdk_bdev_io) retry_io_list; TAILQ_HEAD(retry_io_head, spdk_bdev_io) retry_io_list;
struct spdk_poller *retry_io_poller; struct spdk_poller *retry_io_poller;
@ -353,11 +356,13 @@ typedef void (*bdev_nvme_set_multipath_policy_cb)(void *cb_arg, int rc);
* \param name NVMe bdev name * \param name NVMe bdev name
* \param policy Multipath policy (active-passive or active-active) * \param policy Multipath policy (active-passive or active-active)
* \param selector Multipath selector (round_robin, queue_depth) * \param selector Multipath selector (round_robin, queue_depth)
* \param rr_min_io Number of IO to route to a path before switching to another for round-robin
* \param cb_fn Function to be called back after completion. * \param cb_fn Function to be called back after completion.
*/ */
void bdev_nvme_set_multipath_policy(const char *name, void bdev_nvme_set_multipath_policy(const char *name,
enum bdev_nvme_multipath_policy policy, enum bdev_nvme_multipath_policy policy,
enum bdev_nvme_multipath_selector selector, enum bdev_nvme_multipath_selector selector,
uint32_t rr_min_io,
bdev_nvme_set_multipath_policy_cb cb_fn, bdev_nvme_set_multipath_policy_cb cb_fn,
void *cb_arg); void *cb_arg);

5
module/bdev/nvme/bdev_nvme_rpc.c
View File

@ -2210,6 +2210,7 @@ struct rpc_set_multipath_policy {
char *name; char *name;
enum bdev_nvme_multipath_policy policy; enum bdev_nvme_multipath_policy policy;
enum bdev_nvme_multipath_selector selector; enum bdev_nvme_multipath_selector selector;
uint32_t rr_min_io;
}; };
static void static void
@ -2256,6 +2257,7 @@ static const struct spdk_json_object_decoder rpc_set_multipath_policy_decoders[]
{"name", offsetof(struct rpc_set_multipath_policy, name), spdk_json_decode_string}, {"name", offsetof(struct rpc_set_multipath_policy, name), spdk_json_decode_string},
{"policy", offsetof(struct rpc_set_multipath_policy, policy), rpc_decode_mp_policy}, {"policy", offsetof(struct rpc_set_multipath_policy, policy), rpc_decode_mp_policy},
{"selector", offsetof(struct rpc_set_multipath_policy, selector), rpc_decode_mp_selector, true}, {"selector", offsetof(struct rpc_set_multipath_policy, selector), rpc_decode_mp_selector, true},
{"rr_min_io", offsetof(struct rpc_set_multipath_policy, rr_min_io), spdk_json_decode_uint32, true},
}; };
struct rpc_set_multipath_policy_ctx { struct rpc_set_multipath_policy_ctx {
@ -2290,6 +2292,8 @@ rpc_bdev_nvme_set_multipath_policy(struct spdk_jsonrpc_request *request,
return; return;
} }
ctx->req.rr_min_io = UINT32_MAX;
if (spdk_json_decode_object(params, rpc_set_multipath_policy_decoders, if (spdk_json_decode_object(params, rpc_set_multipath_policy_decoders,
SPDK_COUNTOF(rpc_set_multipath_policy_decoders), SPDK_COUNTOF(rpc_set_multipath_policy_decoders),
&ctx->req)) { &ctx->req)) {
@ -2309,6 +2313,7 @@ rpc_bdev_nvme_set_multipath_policy(struct spdk_jsonrpc_request *request,
} }
bdev_nvme_set_multipath_policy(ctx->req.name, ctx->req.policy, ctx->req.selector, bdev_nvme_set_multipath_policy(ctx->req.name, ctx->req.policy, ctx->req.selector,
ctx->req.rr_min_io,
rpc_bdev_nvme_set_multipath_policy_done, ctx); rpc_bdev_nvme_set_multipath_policy_done, ctx);
return; return;

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

@ -943,19 +943,22 @@ def bdev_nvme_set_preferred_path(client, name, cntlid):
return client.call('bdev_nvme_set_preferred_path', params) return client.call('bdev_nvme_set_preferred_path', params)
def bdev_nvme_set_multipath_policy(client, name, policy, selector): def bdev_nvme_set_multipath_policy(client, name, policy, selector, rr_min_io):
"""Set multipath policy of the NVMe bdev """Set multipath policy of the NVMe bdev
Args: Args:
name: NVMe bdev name name: NVMe bdev name
policy: Multipath policy (active_passive or active_active) policy: Multipath policy (active_passive or active_active)
selector: Multipath selector (round_robin, queue_depth) selector: Multipath selector (round_robin, queue_depth)
rr_min_io: Number of IO to route to a path before switching to another one (optional)
""" """
params = {'name': name, params = {'name': name,
'policy': policy} 'policy': policy}
if selector: if selector:
params['selector'] = selector params['selector'] = selector
if rr_min_io:
params['rr_min_io'] = rr_min_io
return client.call('bdev_nvme_set_multipath_policy', params) return client.call('bdev_nvme_set_multipath_policy', params)

4
scripts/rpc.py
View File

@ -861,13 +861,15 @@ if __name__ == "__main__":
rpc.bdev.bdev_nvme_set_multipath_policy(args.client, rpc.bdev.bdev_nvme_set_multipath_policy(args.client,
name=args.name, name=args.name,
policy=args.policy, policy=args.policy,
selector=args.selector) selector=args.selector,
rr_min_io=args.rr_min_io)
p = subparsers.add_parser('bdev_nvme_set_multipath_policy', p = subparsers.add_parser('bdev_nvme_set_multipath_policy',
help="""Set multipath policy of the NVMe bdev""") help="""Set multipath policy of the NVMe bdev""")
p.add_argument('-b', '--name', help='Name of the NVMe bdev', required=True) p.add_argument('-b', '--name', help='Name of the NVMe bdev', required=True)
p.add_argument('-p', '--policy', help='Multipath policy (active_passive or active_active)', required=True) p.add_argument('-p', '--policy', help='Multipath policy (active_passive or active_active)', required=True)
p.add_argument('-s', '--selector', help='Multipath selector (round_robin, queue_depth)', required=False) p.add_argument('-s', '--selector', help='Multipath selector (round_robin, queue_depth)', required=False)
p.add_argument('-r', '--rr-min-io', help='Number of IO to route to a path before switching to another for round-robin', required=False)
p.set_defaults(func=bdev_nvme_set_multipath_policy) p.set_defaults(func=bdev_nvme_set_multipath_policy)
def bdev_nvme_cuse_register(args): def bdev_nvme_cuse_register(args):

28
test/unit/lib/bdev/nvme/bdev_nvme.c/bdev_nvme_ut.c
View File

@ -5898,6 +5898,22 @@ test_find_next_io_path(void)
nvme_ns2.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; nvme_ns2.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE;
nvme_ns3.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE; nvme_ns3.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE;
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path2); CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path2);
/* Test if next io_path is selected according to rr_min_io */
nbdev_ch.current_io_path = NULL;
nbdev_ch.rr_min_io = 2;
nbdev_ch.rr_counter = 0;
nvme_ns1.ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE;
nvme_ns2.ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE;
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1);
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1);
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path2);
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path2);
nvme_ns3.ana_state = SPDK_NVME_ANA_NON_OPTIMIZED_STATE;
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1);
CU_ASSERT(bdev_nvme_find_io_path(&nbdev_ch) == &io_path1);
} }
static void static void
@ -6177,13 +6193,14 @@ test_set_multipath_policy(void)
*/ */
done = -1; done = -1;
bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE, bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE,
BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH, BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH, UINT32_MAX,
ut_set_multipath_policy_done, &done); ut_set_multipath_policy_done, &done);
poll_threads(); poll_threads();
CU_ASSERT(done == 0); CU_ASSERT(done == 0);
CU_ASSERT(bdev->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE); CU_ASSERT(bdev->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE);
CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH); CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH);
CU_ASSERT(bdev->rr_min_io == UINT32_MAX);
ch = spdk_get_io_channel(bdev); ch = spdk_get_io_channel(bdev);
SPDK_CU_ASSERT_FATAL(ch != NULL); SPDK_CU_ASSERT_FATAL(ch != NULL);
@ -6191,13 +6208,14 @@ test_set_multipath_policy(void)
CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE); CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE);
CU_ASSERT(nbdev_ch->mp_selector == BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH); CU_ASSERT(nbdev_ch->mp_selector == BDEV_NVME_MP_SELECTOR_QUEUE_DEPTH);
CU_ASSERT(nbdev_ch->rr_min_io == UINT32_MAX);
/* If multipath policy is updated while a I/O channel is active, /* If multipath policy is updated while a I/O channel is active,
* the update should be applied to the I/O channel immediately. * the update should be applied to the I/O channel immediately.
*/ */
done = -1; done = -1;
bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE, bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE,
BDEV_NVME_MP_SELECTOR_ROUND_ROBIN, BDEV_NVME_MP_SELECTOR_ROUND_ROBIN, UINT32_MAX,
ut_set_multipath_policy_done, &done); ut_set_multipath_policy_done, &done);
poll_threads(); poll_threads();
CU_ASSERT(done == 0); CU_ASSERT(done == 0);
@ -6206,6 +6224,8 @@ test_set_multipath_policy(void)
CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE); CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_PASSIVE);
CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN); CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN);
CU_ASSERT(nbdev_ch->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN); CU_ASSERT(nbdev_ch->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN);
CU_ASSERT(bdev->rr_min_io == UINT32_MAX);
CU_ASSERT(nbdev_ch->rr_min_io == UINT32_MAX);
spdk_put_io_channel(ch); spdk_put_io_channel(ch);
@ -6325,12 +6345,13 @@ test_retry_io_to_same_path(void)
done = -1; done = -1;
bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE, bdev_nvme_set_multipath_policy(bdev->disk.name, BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE,
BDEV_NVME_MP_SELECTOR_ROUND_ROBIN, ut_set_multipath_policy_done, &done); BDEV_NVME_MP_SELECTOR_ROUND_ROBIN, 1, ut_set_multipath_policy_done, &done);
poll_threads(); poll_threads();
CU_ASSERT(done == 0); CU_ASSERT(done == 0);
CU_ASSERT(bdev->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE); CU_ASSERT(bdev->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE);
CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN); CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN);
CU_ASSERT(bdev->rr_min_io == 1);
ch = spdk_get_io_channel(bdev); ch = spdk_get_io_channel(bdev);
SPDK_CU_ASSERT_FATAL(ch != NULL); SPDK_CU_ASSERT_FATAL(ch != NULL);
@ -6338,6 +6359,7 @@ test_retry_io_to_same_path(void)
CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE); CU_ASSERT(nbdev_ch->mp_policy == BDEV_NVME_MP_POLICY_ACTIVE_ACTIVE);
CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN); CU_ASSERT(bdev->mp_selector == BDEV_NVME_MP_SELECTOR_ROUND_ROBIN);
CU_ASSERT(nbdev_ch->rr_min_io == 1);
bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, ch); bdev_io = ut_alloc_bdev_io(SPDK_BDEV_IO_TYPE_WRITE, bdev, ch);
ut_bdev_io_set_buf(bdev_io); ut_bdev_io_set_buf(bdev_io);