4 * Copyright (c) Intel Corporation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include "spdk/stdinc.h"
35 #include "spdk_cunit.h"
37 #include "spdk_internal/mock.h"
38 #include "bdev/raid/bdev_raid.c"
39 #include "bdev/raid/bdev_raid_rpc.c"
41 #define MAX_BASE_DRIVES 32
43 #define INVALID_IO_SUBMIT 0xFFFF
44 #define MAX_TEST_IO_RANGE (3 * 3 * 3 * (MAX_BASE_DRIVES + 5))
45 #define BLOCK_CNT (1024ul * 1024ul * 1024ul * 1024ul)
47 /* Data structure to capture the output of IO for verification */
49 struct spdk_bdev_desc
*desc
;
50 struct spdk_io_channel
*ch
;
51 uint64_t offset_blocks
;
53 spdk_bdev_io_completion_cb cb
;
55 enum spdk_bdev_io_type iotype
;
58 struct raid_io_ranges
{
64 int g_bdev_io_submit_status
;
65 struct io_output
*g_io_output
= NULL
;
66 uint32_t g_io_output_index
;
67 uint32_t g_io_comp_status
;
68 bool g_child_io_status_flag
;
70 uint32_t rpc_req_size
;
71 TAILQ_HEAD(bdev
, spdk_bdev
);
72 struct bdev g_bdev_list
;
73 TAILQ_HEAD(waitq
, spdk_bdev_io_wait_entry
);
74 struct waitq g_io_waitq
;
76 uint32_t g_strip_size
;
77 uint32_t g_max_io_size
;
78 uint8_t g_max_base_drives
;
80 uint8_t g_ignore_io_output
;
82 char *g_get_raids_output
[MAX_RAIDS
];
83 uint32_t g_get_raids_count
;
84 uint8_t g_json_beg_res_ret_err
;
85 uint8_t g_json_decode_obj_err
;
86 uint8_t g_json_decode_obj_construct
;
87 uint8_t g_config_level_create
= 0;
88 uint8_t g_test_multi_raids
;
89 struct raid_io_ranges g_io_ranges
[MAX_TEST_IO_RANGE
];
90 uint32_t g_io_range_idx
;
91 uint64_t g_lba_offset
;
93 DEFINE_STUB(spdk_bdev_flush_blocks
, int, (struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
94 uint64_t offset_blocks
, uint64_t num_blocks
, spdk_bdev_io_completion_cb cb
,
96 DEFINE_STUB(spdk_bdev_io_type_supported
, bool, (struct spdk_bdev
*bdev
,
97 enum spdk_bdev_io_type io_type
), true);
98 DEFINE_STUB(spdk_get_io_channel
, struct spdk_io_channel
*, (void *io_device
), NULL
);
99 DEFINE_STUB_V(spdk_io_device_unregister
, (void *io_device
,
100 spdk_io_device_unregister_cb unregister_cb
));
101 DEFINE_STUB_V(spdk_io_device_register
, (void *io_device
, spdk_io_channel_create_cb create_cb
,
102 spdk_io_channel_destroy_cb destroy_cb
, uint32_t ctx_size
,
104 DEFINE_STUB(spdk_json_write_name
, int, (struct spdk_json_write_ctx
*w
, const char *name
), 0);
105 DEFINE_STUB(spdk_json_write_named_string
, int, (struct spdk_json_write_ctx
*w
,
106 const char *name
, const char *val
), 0);
107 DEFINE_STUB(spdk_json_write_object_begin
, int, (struct spdk_json_write_ctx
*w
), 0);
108 DEFINE_STUB(spdk_json_write_named_object_begin
, int, (struct spdk_json_write_ctx
*w
,
109 const char *name
), 0);
110 DEFINE_STUB(spdk_json_write_named_array_begin
, int, (struct spdk_json_write_ctx
*w
,
111 const char *name
), 0);
112 DEFINE_STUB(spdk_json_write_array_end
, int, (struct spdk_json_write_ctx
*w
), 0);
113 DEFINE_STUB(spdk_json_write_object_end
, int, (struct spdk_json_write_ctx
*w
), 0);
114 DEFINE_STUB(spdk_json_write_bool
, int, (struct spdk_json_write_ctx
*w
, bool val
), 0);
115 DEFINE_STUB(spdk_json_write_null
, int, (struct spdk_json_write_ctx
*w
), 0);
116 DEFINE_STUB(spdk_bdev_get_io_channel
, struct spdk_io_channel
*, (struct spdk_bdev_desc
*desc
),
118 DEFINE_STUB_V(spdk_bdev_module_examine_done
, (struct spdk_bdev_module
*module
));
119 DEFINE_STUB(spdk_conf_next_section
, struct spdk_conf_section
*, (struct spdk_conf_section
*sp
),
121 DEFINE_STUB_V(spdk_bdev_close
, (struct spdk_bdev_desc
*desc
));
122 DEFINE_STUB(spdk_bdev_register
, int, (struct spdk_bdev
*bdev
), 0);
123 DEFINE_STUB(spdk_json_decode_string
, int, (const struct spdk_json_val
*val
, void *out
), 0);
124 DEFINE_STUB_V(spdk_jsonrpc_end_result
, (struct spdk_jsonrpc_request
*request
,
125 struct spdk_json_write_ctx
*w
));
126 DEFINE_STUB(spdk_json_write_array_begin
, int, (struct spdk_json_write_ctx
*w
), 0);
127 DEFINE_STUB(spdk_strerror
, const char *, (int errnum
), NULL
);
128 DEFINE_STUB(spdk_json_decode_array
, int, (const struct spdk_json_val
*values
,
129 spdk_json_decode_fn decode_func
,
130 void *out
, size_t max_size
, size_t *out_size
, size_t stride
), 0);
131 DEFINE_STUB_V(spdk_rpc_register_method
, (const char *method
, spdk_rpc_method_handler func
,
132 uint32_t state_mask
));
133 DEFINE_STUB(spdk_json_decode_uint32
, int, (const struct spdk_json_val
*val
, void *out
), 0);
134 DEFINE_STUB_V(spdk_bdev_module_list_add
, (struct spdk_bdev_module
*bdev_module
));
140 g_max_base_drives
= MAX_BASE_DRIVES
;
141 g_max_raids
= MAX_RAIDS
;
144 g_max_io_size
= 1024;
146 printf("Test Options\n");
147 printf("blocklen = %u, strip_size = %u, max_io_size = %u, g_max_base_drives = %u, g_max_raids = %u\n",
148 g_block_len
, g_strip_size
, g_max_io_size
, g_max_base_drives
, g_max_raids
);
151 /* Set globals before every test run */
157 g_bdev_io_submit_status
= 0;
158 if (g_max_io_size
< g_strip_size
) {
161 max_splits
= (g_max_io_size
/ g_strip_size
) + 1;
163 if (max_splits
< g_max_base_drives
) {
164 max_splits
= g_max_base_drives
;
167 g_io_output
= calloc(max_splits
, sizeof(struct io_output
));
168 SPDK_CU_ASSERT_FATAL(g_io_output
!= NULL
);
169 g_io_output_index
= 0;
170 memset(g_get_raids_output
, 0, sizeof(g_get_raids_output
));
171 g_get_raids_count
= 0;
172 g_io_comp_status
= 0;
173 g_ignore_io_output
= 0;
174 g_config_level_create
= 0;
176 g_test_multi_raids
= 0;
177 g_child_io_status_flag
= true;
178 TAILQ_INIT(&g_bdev_list
);
179 TAILQ_INIT(&g_io_waitq
);
182 g_json_beg_res_ret_err
= 0;
183 g_json_decode_obj_err
= 0;
184 g_json_decode_obj_construct
= 0;
189 base_bdevs_cleanup(void)
191 struct spdk_bdev
*bdev
;
192 struct spdk_bdev
*bdev_next
;
194 if (!TAILQ_EMPTY(&g_bdev_list
)) {
195 TAILQ_FOREACH_SAFE(bdev
, &g_bdev_list
, internal
.link
, bdev_next
) {
197 TAILQ_REMOVE(&g_bdev_list
, bdev
, internal
.link
);
204 check_and_remove_raid_bdev(struct raid_bdev_config
*raid_cfg
)
206 struct raid_bdev
*raid_bdev
;
208 /* Get the raid structured allocated if exists */
209 raid_bdev
= raid_cfg
->raid_bdev
;
210 if (raid_bdev
== NULL
) {
214 for (uint32_t i
= 0; i
< raid_bdev
->num_base_bdevs
; i
++) {
215 assert(raid_bdev
->base_bdev_info
!= NULL
);
216 if (raid_bdev
->base_bdev_info
[i
].bdev
) {
217 raid_bdev_free_base_bdev_resource(raid_bdev
, i
);
220 assert(raid_bdev
->num_base_bdevs_discovered
== 0);
221 raid_bdev_cleanup(raid_bdev
);
237 spdk_bdev_io_get_buf(struct spdk_bdev_io
*bdev_io
, spdk_bdev_io_get_buf_cb cb
,
243 /* Store the IO completion status in global variable to verify by various tests */
245 spdk_bdev_io_complete(struct spdk_bdev_io
*bdev_io
, enum spdk_bdev_io_status status
)
247 g_io_comp_status
= ((status
== SPDK_BDEV_IO_STATUS_SUCCESS
) ? true : false);
250 /* It will cache the split IOs for verification */
252 spdk_bdev_writev_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
253 struct iovec
*iov
, int iovcnt
,
254 uint64_t offset_blocks
, uint64_t num_blocks
,
255 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
257 struct io_output
*p
= &g_io_output
[g_io_output_index
];
258 struct spdk_bdev_io
*child_io
;
260 if (g_ignore_io_output
) {
264 if (g_max_io_size
< g_strip_size
) {
265 SPDK_CU_ASSERT_FATAL(g_io_output_index
< 2);
267 SPDK_CU_ASSERT_FATAL(g_io_output_index
< (g_max_io_size
/ g_strip_size
) + 1);
269 if (g_bdev_io_submit_status
== 0) {
272 p
->offset_blocks
= offset_blocks
;
273 p
->num_blocks
= num_blocks
;
276 p
->iotype
= SPDK_BDEV_IO_TYPE_WRITE
;
278 child_io
= calloc(1, sizeof(struct spdk_bdev_io
));
279 SPDK_CU_ASSERT_FATAL(child_io
!= NULL
);
280 cb(child_io
, g_child_io_status_flag
, cb_arg
);
283 return g_bdev_io_submit_status
;
287 spdk_bdev_reset(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
288 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
290 struct io_output
*p
= &g_io_output
[g_io_output_index
];
291 struct spdk_bdev_io
*child_io
;
293 if (g_ignore_io_output
) {
297 if (g_bdev_io_submit_status
== 0) {
302 p
->iotype
= SPDK_BDEV_IO_TYPE_RESET
;
304 child_io
= calloc(1, sizeof(struct spdk_bdev_io
));
305 SPDK_CU_ASSERT_FATAL(child_io
!= NULL
);
306 cb(child_io
, g_child_io_status_flag
, cb_arg
);
309 return g_bdev_io_submit_status
;
313 spdk_bdev_unmap_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
314 uint64_t offset_blocks
, uint64_t num_blocks
,
315 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
317 struct io_output
*p
= &g_io_output
[g_io_output_index
];
318 struct spdk_bdev_io
*child_io
;
320 if (g_ignore_io_output
) {
324 if (g_bdev_io_submit_status
== 0) {
327 p
->offset_blocks
= offset_blocks
;
328 p
->num_blocks
= num_blocks
;
331 p
->iotype
= SPDK_BDEV_IO_TYPE_UNMAP
;
333 child_io
= calloc(1, sizeof(struct spdk_bdev_io
));
334 SPDK_CU_ASSERT_FATAL(child_io
!= NULL
);
335 cb(child_io
, g_child_io_status_flag
, cb_arg
);
338 return g_bdev_io_submit_status
;
342 spdk_bdev_unregister(struct spdk_bdev
*bdev
, spdk_bdev_unregister_cb cb_fn
, void *cb_arg
)
344 bdev
->fn_table
->destruct(bdev
->ctxt
);
352 spdk_bdev_open(struct spdk_bdev
*bdev
, bool write
, spdk_bdev_remove_cb_t remove_cb
,
353 void *remove_ctx
, struct spdk_bdev_desc
**_desc
)
355 *_desc
= (void *)0x1;
360 spdk_put_io_channel(struct spdk_io_channel
*ch
)
362 CU_ASSERT(ch
== (void *)1);
366 spdk_sprintf_alloc(const char *format
, ...)
368 return strdup(format
);
371 int spdk_json_write_named_uint32(struct spdk_json_write_ctx
*w
, const char *name
, uint32_t val
)
373 struct rpc_construct_raid_bdev
*req
= rpc_req
;
374 if (strcmp(name
, "strip_size_kb") == 0) {
375 CU_ASSERT(req
->strip_size_kb
== val
);
376 } else if (strcmp(name
, "blocklen_shift") == 0) {
377 CU_ASSERT(spdk_u32log2(g_block_len
) == val
);
378 } else if (strcmp(name
, "raid_level") == 0) {
379 CU_ASSERT(req
->raid_level
== val
);
380 } else if (strcmp(name
, "num_base_bdevs") == 0) {
381 CU_ASSERT(req
->base_bdevs
.num_base_bdevs
== val
);
382 } else if (strcmp(name
, "state") == 0) {
383 CU_ASSERT(val
== RAID_BDEV_STATE_ONLINE
);
384 } else if (strcmp(name
, "destruct_called") == 0) {
386 } else if (strcmp(name
, "num_base_bdevs_discovered") == 0) {
387 CU_ASSERT(req
->base_bdevs
.num_base_bdevs
== val
);
393 spdk_for_each_thread(spdk_msg_fn fn
, void *ctx
, spdk_msg_fn cpl
)
400 spdk_thread_send_msg(const struct spdk_thread
*thread
, spdk_msg_fn fn
, void *ctx
)
406 spdk_bdev_free_io(struct spdk_bdev_io
*bdev_io
)
413 /* It will cache split IOs for verification */
415 spdk_bdev_readv_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
416 struct iovec
*iov
, int iovcnt
,
417 uint64_t offset_blocks
, uint64_t num_blocks
,
418 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
420 struct io_output
*p
= &g_io_output
[g_io_output_index
];
421 struct spdk_bdev_io
*child_io
;
423 if (g_ignore_io_output
) {
427 SPDK_CU_ASSERT_FATAL(g_io_output_index
<= (g_max_io_size
/ g_strip_size
) + 1);
428 if (g_bdev_io_submit_status
== 0) {
431 p
->offset_blocks
= offset_blocks
;
432 p
->num_blocks
= num_blocks
;
435 p
->iotype
= SPDK_BDEV_IO_TYPE_READ
;
437 child_io
= calloc(1, sizeof(struct spdk_bdev_io
));
438 SPDK_CU_ASSERT_FATAL(child_io
!= NULL
);
439 cb(child_io
, g_child_io_status_flag
, cb_arg
);
442 return g_bdev_io_submit_status
;
446 spdk_bdev_module_release_bdev(struct spdk_bdev
*bdev
)
448 CU_ASSERT(bdev
->internal
.claim_module
!= NULL
);
449 bdev
->internal
.claim_module
= NULL
;
452 struct spdk_conf_section
*
453 spdk_conf_first_section(struct spdk_conf
*cp
)
455 if (g_config_level_create
) {
463 spdk_conf_section_match_prefix(const struct spdk_conf_section
*sp
, const char *name_prefix
)
465 if (g_config_level_create
) {
473 spdk_conf_section_get_val(struct spdk_conf_section
*sp
, const char *key
)
475 struct rpc_construct_raid_bdev
*req
= rpc_req
;
477 if (g_config_level_create
) {
478 if (strcmp(key
, "Name") == 0) {
487 spdk_conf_section_get_intval(struct spdk_conf_section
*sp
, const char *key
)
489 struct rpc_construct_raid_bdev
*req
= rpc_req
;
491 if (g_config_level_create
) {
492 if (strcmp(key
, "StripSize") == 0) {
493 return req
->strip_size_kb
;
494 } else if (strcmp(key
, "NumDevices") == 0) {
495 return req
->base_bdevs
.num_base_bdevs
;
496 } else if (strcmp(key
, "RaidLevel") == 0) {
497 return req
->raid_level
;
505 spdk_conf_section_get_nmval(struct spdk_conf_section
*sp
, const char *key
, int idx1
, int idx2
)
507 struct rpc_construct_raid_bdev
*req
= rpc_req
;
509 if (g_config_level_create
) {
510 if (strcmp(key
, "Devices") == 0) {
511 if (idx2
>= g_max_base_drives
) {
514 return req
->base_bdevs
.base_bdevs
[idx2
];
522 spdk_bdev_module_claim_bdev(struct spdk_bdev
*bdev
, struct spdk_bdev_desc
*desc
,
523 struct spdk_bdev_module
*module
)
525 if (bdev
->internal
.claim_module
!= NULL
) {
528 bdev
->internal
.claim_module
= module
;
533 spdk_json_decode_object(const struct spdk_json_val
*values
,
534 const struct spdk_json_object_decoder
*decoders
, size_t num_decoders
, void *out
)
536 struct rpc_construct_raid_bdev
*req
, *_out
;
539 if (g_json_decode_obj_err
) {
541 } else if (g_json_decode_obj_construct
) {
545 _out
->name
= strdup(req
->name
);
546 SPDK_CU_ASSERT_FATAL(_out
->name
!= NULL
);
547 _out
->strip_size_kb
= req
->strip_size_kb
;
548 _out
->raid_level
= req
->raid_level
;
549 _out
->base_bdevs
.num_base_bdevs
= req
->base_bdevs
.num_base_bdevs
;
550 for (i
= 0; i
< req
->base_bdevs
.num_base_bdevs
; i
++) {
551 _out
->base_bdevs
.base_bdevs
[i
] = strdup(req
->base_bdevs
.base_bdevs
[i
]);
552 SPDK_CU_ASSERT_FATAL(_out
->base_bdevs
.base_bdevs
[i
]);
555 memcpy(out
, rpc_req
, rpc_req_size
);
561 struct spdk_json_write_ctx
*
562 spdk_jsonrpc_begin_result(struct spdk_jsonrpc_request
*request
)
564 if (g_json_beg_res_ret_err
) {
572 spdk_json_write_string(struct spdk_json_write_ctx
*w
, const char *val
)
574 if (g_test_multi_raids
) {
575 g_get_raids_output
[g_get_raids_count
] = strdup(val
);
576 SPDK_CU_ASSERT_FATAL(g_get_raids_output
[g_get_raids_count
] != NULL
);
584 spdk_jsonrpc_send_error_response(struct spdk_jsonrpc_request
*request
,
585 int error_code
, const char *msg
)
591 spdk_jsonrpc_send_error_response_fmt(struct spdk_jsonrpc_request
*request
,
592 int error_code
, const char *fmt
, ...)
598 spdk_bdev_get_by_name(const char *bdev_name
)
600 struct spdk_bdev
*bdev
;
602 if (!TAILQ_EMPTY(&g_bdev_list
)) {
603 TAILQ_FOREACH(bdev
, &g_bdev_list
, internal
.link
) {
604 if (strcmp(bdev_name
, bdev
->name
) == 0) {
614 bdev_io_cleanup(struct spdk_bdev_io
*bdev_io
)
616 if (bdev_io
->u
.bdev
.iovs
) {
617 if (bdev_io
->u
.bdev
.iovs
->iov_base
) {
618 free(bdev_io
->u
.bdev
.iovs
->iov_base
);
619 bdev_io
->u
.bdev
.iovs
->iov_base
= NULL
;
621 free(bdev_io
->u
.bdev
.iovs
);
622 bdev_io
->u
.bdev
.iovs
= NULL
;
627 bdev_io_initialize(struct spdk_bdev_io
*bdev_io
, struct spdk_bdev
*bdev
,
628 uint64_t lba
, uint64_t blocks
, int16_t iotype
)
630 bdev_io
->bdev
= bdev
;
631 bdev_io
->u
.bdev
.offset_blocks
= lba
;
632 bdev_io
->u
.bdev
.num_blocks
= blocks
;
633 bdev_io
->type
= iotype
;
635 if (bdev_io
->type
== SPDK_BDEV_IO_TYPE_UNMAP
|| bdev_io
->type
== SPDK_BDEV_IO_TYPE_FLUSH
) {
639 bdev_io
->u
.bdev
.iovcnt
= 1;
640 bdev_io
->u
.bdev
.iovs
= calloc(1, sizeof(struct iovec
));
641 SPDK_CU_ASSERT_FATAL(bdev_io
->u
.bdev
.iovs
!= NULL
);
642 bdev_io
->u
.bdev
.iovs
->iov_base
= calloc(1, bdev_io
->u
.bdev
.num_blocks
* g_block_len
);
643 SPDK_CU_ASSERT_FATAL(bdev_io
->u
.bdev
.iovs
->iov_base
!= NULL
);
644 bdev_io
->u
.bdev
.iovs
->iov_len
= bdev_io
->u
.bdev
.num_blocks
* g_block_len
;
648 verify_reset_io(struct spdk_bdev_io
*bdev_io
, uint8_t num_base_drives
,
649 struct raid_bdev_io_channel
*ch_ctx
, struct raid_bdev
*raid_bdev
, uint32_t io_status
)
653 SPDK_CU_ASSERT_FATAL(raid_bdev
!= NULL
);
654 SPDK_CU_ASSERT_FATAL(num_base_drives
!= 0);
655 SPDK_CU_ASSERT_FATAL(io_status
!= INVALID_IO_SUBMIT
);
657 CU_ASSERT(g_io_output_index
== num_base_drives
);
658 for (index
= 0; index
< g_io_output_index
; index
++) {
659 CU_ASSERT(ch_ctx
->base_channel
[index
] == g_io_output
[index
].ch
);
660 CU_ASSERT(raid_bdev
->base_bdev_info
[index
].desc
== g_io_output
[index
].desc
);
661 CU_ASSERT(bdev_io
->type
== g_io_output
[index
].iotype
);
663 CU_ASSERT(g_io_comp_status
== io_status
);
667 verify_io(struct spdk_bdev_io
*bdev_io
, uint8_t num_base_drives
,
668 struct raid_bdev_io_channel
*ch_ctx
, struct raid_bdev
*raid_bdev
, uint32_t io_status
)
670 uint32_t strip_shift
= spdk_u32log2(g_strip_size
);
671 uint64_t start_strip
= bdev_io
->u
.bdev
.offset_blocks
>> strip_shift
;
672 uint64_t end_strip
= (bdev_io
->u
.bdev
.offset_blocks
+ bdev_io
->u
.bdev
.num_blocks
- 1) >>
674 uint32_t splits_reqd
= (end_strip
- start_strip
+ 1);
678 uint32_t offset_in_strip
;
682 uint8_t *buf
= bdev_io
->u
.bdev
.iovs
->iov_base
;
684 if (io_status
== INVALID_IO_SUBMIT
) {
685 CU_ASSERT(g_io_comp_status
== false);
688 SPDK_CU_ASSERT_FATAL(raid_bdev
!= NULL
);
689 SPDK_CU_ASSERT_FATAL(num_base_drives
!= 0);
691 CU_ASSERT(splits_reqd
== g_io_output_index
);
692 for (strip
= start_strip
; strip
<= end_strip
; strip
++, index
++) {
693 pd_strip
= strip
/ num_base_drives
;
694 pd_idx
= strip
% num_base_drives
;
695 if (strip
== start_strip
) {
696 offset_in_strip
= bdev_io
->u
.bdev
.offset_blocks
& (g_strip_size
- 1);
697 pd_lba
= (pd_strip
<< strip_shift
) + offset_in_strip
;
698 if (strip
== end_strip
) {
699 pd_blocks
= bdev_io
->u
.bdev
.num_blocks
;
701 pd_blocks
= g_strip_size
- offset_in_strip
;
703 } else if (strip
== end_strip
) {
704 pd_lba
= pd_strip
<< strip_shift
;
705 pd_blocks
= ((bdev_io
->u
.bdev
.offset_blocks
+ bdev_io
->u
.bdev
.num_blocks
- 1) &
706 (g_strip_size
- 1)) + 1;
708 pd_lba
= pd_strip
<< raid_bdev
->strip_size_shift
;
709 pd_blocks
= raid_bdev
->strip_size
;
711 CU_ASSERT(pd_lba
== g_io_output
[index
].offset_blocks
);
712 CU_ASSERT(pd_blocks
== g_io_output
[index
].num_blocks
);
713 CU_ASSERT(ch_ctx
->base_channel
[pd_idx
] == g_io_output
[index
].ch
);
714 CU_ASSERT(raid_bdev
->base_bdev_info
[pd_idx
].desc
== g_io_output
[index
].desc
);
715 CU_ASSERT(bdev_io
->type
== g_io_output
[index
].iotype
);
716 buf
+= (pd_blocks
<< spdk_u32log2(g_block_len
));
718 CU_ASSERT(g_io_comp_status
== io_status
);
722 verify_io_without_payload(struct spdk_bdev_io
*bdev_io
, uint8_t num_base_drives
,
723 struct raid_bdev_io_channel
*ch_ctx
, struct raid_bdev
*raid_bdev
, uint32_t io_status
)
725 uint32_t strip_shift
= spdk_u32log2(g_strip_size
);
726 uint64_t start_offset_in_strip
= bdev_io
->u
.bdev
.offset_blocks
% g_strip_size
;
727 uint64_t end_offset_in_strip
= (bdev_io
->u
.bdev
.offset_blocks
+ bdev_io
->u
.bdev
.num_blocks
- 1) %
729 uint64_t start_strip
= bdev_io
->u
.bdev
.offset_blocks
>> strip_shift
;
730 uint64_t end_strip
= (bdev_io
->u
.bdev
.offset_blocks
+ bdev_io
->u
.bdev
.num_blocks
- 1) >>
732 uint32_t n_disks_involved
;
733 uint64_t start_strip_disk_idx
;
734 uint64_t end_strip_disk_idx
;
735 uint64_t nblocks_in_start_disk
;
736 uint64_t offset_in_start_disk
;
738 uint64_t base_io_idx
;
739 uint64_t sum_nblocks
= 0;
741 if (io_status
== INVALID_IO_SUBMIT
) {
742 CU_ASSERT(g_io_comp_status
== false);
745 SPDK_CU_ASSERT_FATAL(raid_bdev
!= NULL
);
746 SPDK_CU_ASSERT_FATAL(num_base_drives
!= 0);
747 SPDK_CU_ASSERT_FATAL(bdev_io
->type
!= SPDK_BDEV_IO_TYPE_READ
);
748 SPDK_CU_ASSERT_FATAL(bdev_io
->type
!= SPDK_BDEV_IO_TYPE_WRITE
);
750 n_disks_involved
= spdk_min(end_strip
- start_strip
+ 1, num_base_drives
);
751 CU_ASSERT(n_disks_involved
== g_io_output_index
);
753 start_strip_disk_idx
= start_strip
% num_base_drives
;
754 end_strip_disk_idx
= end_strip
% num_base_drives
;
755 offset_in_start_disk
= g_io_output
[0].offset_blocks
;
756 nblocks_in_start_disk
= g_io_output
[0].num_blocks
;
758 for (base_io_idx
= 0, disk_idx
= start_strip_disk_idx
; base_io_idx
< n_disks_involved
;
759 base_io_idx
++, disk_idx
++) {
760 uint64_t start_offset_in_disk
;
761 uint64_t end_offset_in_disk
;
764 if (disk_idx
>= num_base_drives
) {
765 disk_idx
%= num_base_drives
;
768 /* start_offset_in_disk aligned in strip check:
769 * The first base io has a same start_offset_in_strip with the whole raid io.
770 * Other base io should have aligned start_offset_in_strip which is 0.
772 start_offset_in_disk
= g_io_output
[base_io_idx
].offset_blocks
;
773 if (base_io_idx
== 0) {
774 CU_ASSERT(start_offset_in_disk
% g_strip_size
== start_offset_in_strip
);
776 CU_ASSERT(start_offset_in_disk
% g_strip_size
== 0);
779 /* end_offset_in_disk aligned in strip check:
780 * Base io on disk at which end_strip is located, has a same end_offset_in_strip with the whole raid io.
781 * Other base io should have aligned end_offset_in_strip.
783 end_offset_in_disk
= g_io_output
[base_io_idx
].offset_blocks
+
784 g_io_output
[base_io_idx
].num_blocks
- 1;
785 if (disk_idx
== end_strip_disk_idx
) {
786 CU_ASSERT(end_offset_in_disk
% g_strip_size
== end_offset_in_strip
);
788 CU_ASSERT(end_offset_in_disk
% g_strip_size
== g_strip_size
- 1);
791 /* start_offset_in_disk compared with start_disk.
792 * 1. For disk_idx which is larger than start_strip_disk_idx: Its start_offset_in_disk mustn't be
793 * larger than the start offset of start_offset_in_disk; And the gap must be less than strip size.
794 * 2. For disk_idx which is less than start_strip_disk_idx, Its start_offset_in_disk must be
795 * larger than the start offset of start_offset_in_disk; And the gap mustn't be less than strip size.
797 if (disk_idx
> start_strip_disk_idx
) {
798 CU_ASSERT(start_offset_in_disk
<= offset_in_start_disk
);
799 CU_ASSERT(offset_in_start_disk
- start_offset_in_disk
< g_strip_size
);
800 } else if (disk_idx
< start_strip_disk_idx
) {
801 CU_ASSERT(start_offset_in_disk
> offset_in_start_disk
);
802 CU_ASSERT(g_io_output
[base_io_idx
].offset_blocks
- offset_in_start_disk
<= g_strip_size
);
805 /* nblocks compared with start_disk:
806 * The gap between them must be within a strip size.
808 if (g_io_output
[base_io_idx
].num_blocks
<= nblocks_in_start_disk
) {
809 CU_ASSERT(nblocks_in_start_disk
- g_io_output
[base_io_idx
].num_blocks
<= g_strip_size
);
811 CU_ASSERT(g_io_output
[base_io_idx
].num_blocks
- nblocks_in_start_disk
< g_strip_size
);
814 sum_nblocks
+= g_io_output
[base_io_idx
].num_blocks
;
816 CU_ASSERT(ch_ctx
->base_channel
[disk_idx
] == g_io_output
[base_io_idx
].ch
);
817 CU_ASSERT(raid_bdev
->base_bdev_info
[disk_idx
].desc
== g_io_output
[base_io_idx
].desc
);
818 CU_ASSERT(bdev_io
->type
== g_io_output
[base_io_idx
].iotype
);
821 /* Sum of each nblocks should be same with raid bdev_io */
822 CU_ASSERT(bdev_io
->u
.bdev
.num_blocks
== sum_nblocks
);
824 CU_ASSERT(g_io_comp_status
== io_status
);
828 verify_raid_config_present(const char *name
, bool presence
)
830 struct raid_bdev_config
*raid_cfg
;
835 TAILQ_FOREACH(raid_cfg
, &g_raid_config
.raid_bdev_config_head
, link
) {
836 if (raid_cfg
->name
!= NULL
) {
837 if (strcmp(name
, raid_cfg
->name
) == 0) {
844 if (presence
== true) {
845 CU_ASSERT(cfg_found
== true);
847 CU_ASSERT(cfg_found
== false);
852 verify_raid_bdev_present(const char *name
, bool presence
)
854 struct raid_bdev
*pbdev
;
858 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
859 if (strcmp(pbdev
->bdev
.name
, name
) == 0) {
864 if (presence
== true) {
865 CU_ASSERT(pbdev_found
== true);
867 CU_ASSERT(pbdev_found
== false);
871 verify_raid_config(struct rpc_construct_raid_bdev
*r
, bool presence
)
873 struct raid_bdev_config
*raid_cfg
= NULL
;
877 TAILQ_FOREACH(raid_cfg
, &g_raid_config
.raid_bdev_config_head
, link
) {
878 if (strcmp(r
->name
, raid_cfg
->name
) == 0) {
879 if (presence
== false) {
882 CU_ASSERT(raid_cfg
->raid_bdev
!= NULL
);
883 CU_ASSERT(raid_cfg
->strip_size
== r
->strip_size_kb
);
884 CU_ASSERT(raid_cfg
->num_base_bdevs
== r
->base_bdevs
.num_base_bdevs
);
885 CU_ASSERT(raid_cfg
->raid_level
== r
->raid_level
);
886 if (raid_cfg
->base_bdev
!= NULL
) {
887 for (i
= 0; i
< raid_cfg
->num_base_bdevs
; i
++) {
888 val
= strcmp(raid_cfg
->base_bdev
[i
].name
, r
->base_bdevs
.base_bdevs
[i
]);
896 if (presence
== true) {
897 CU_ASSERT(raid_cfg
!= NULL
);
899 CU_ASSERT(raid_cfg
== NULL
);
904 verify_raid_bdev(struct rpc_construct_raid_bdev
*r
, bool presence
, uint32_t raid_state
)
906 struct raid_bdev
*pbdev
;
908 struct spdk_bdev
*bdev
= NULL
;
910 uint64_t min_blockcnt
= 0xFFFFFFFFFFFFFFFF;
913 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
914 if (strcmp(pbdev
->bdev
.name
, r
->name
) == 0) {
916 if (presence
== false) {
919 CU_ASSERT(pbdev
->config
->raid_bdev
== pbdev
);
920 CU_ASSERT(pbdev
->base_bdev_info
!= NULL
);
921 CU_ASSERT(pbdev
->strip_size
== ((r
->strip_size_kb
* 1024) / g_block_len
));
922 CU_ASSERT(pbdev
->strip_size_shift
== spdk_u32log2(((r
->strip_size_kb
* 1024) / g_block_len
)));
923 CU_ASSERT(pbdev
->blocklen_shift
== spdk_u32log2(g_block_len
));
924 CU_ASSERT(pbdev
->state
== raid_state
);
925 CU_ASSERT(pbdev
->num_base_bdevs
== r
->base_bdevs
.num_base_bdevs
);
926 CU_ASSERT(pbdev
->num_base_bdevs_discovered
== r
->base_bdevs
.num_base_bdevs
);
927 CU_ASSERT(pbdev
->raid_level
== r
->raid_level
);
928 CU_ASSERT(pbdev
->destruct_called
== false);
929 for (i
= 0; i
< pbdev
->num_base_bdevs
; i
++) {
930 if (pbdev
->base_bdev_info
&& pbdev
->base_bdev_info
[i
].bdev
) {
931 bdev
= spdk_bdev_get_by_name(pbdev
->base_bdev_info
[i
].bdev
->name
);
932 CU_ASSERT(bdev
!= NULL
);
933 CU_ASSERT(pbdev
->base_bdev_info
[i
].remove_scheduled
== false);
938 if (bdev
&& bdev
->blockcnt
< min_blockcnt
) {
939 min_blockcnt
= bdev
->blockcnt
;
942 CU_ASSERT((((min_blockcnt
/ (r
->strip_size_kb
* 1024 / g_block_len
)) * (r
->strip_size_kb
* 1024 /
943 g_block_len
)) * r
->base_bdevs
.num_base_bdevs
) == pbdev
->bdev
.blockcnt
);
944 CU_ASSERT(strcmp(pbdev
->bdev
.product_name
, "Raid Volume") == 0);
945 CU_ASSERT(pbdev
->bdev
.write_cache
== 0);
946 CU_ASSERT(pbdev
->bdev
.blocklen
== g_block_len
);
947 if (pbdev
->num_base_bdevs
> 1) {
948 CU_ASSERT(pbdev
->bdev
.optimal_io_boundary
== pbdev
->strip_size
);
949 CU_ASSERT(pbdev
->bdev
.split_on_optimal_io_boundary
== true);
951 CU_ASSERT(pbdev
->bdev
.optimal_io_boundary
== 0);
952 CU_ASSERT(pbdev
->bdev
.split_on_optimal_io_boundary
== false);
954 CU_ASSERT(pbdev
->bdev
.ctxt
== pbdev
);
955 CU_ASSERT(pbdev
->bdev
.fn_table
== &g_raid_bdev_fn_table
);
956 CU_ASSERT(pbdev
->bdev
.module
== &g_raid_if
);
960 if (presence
== true) {
961 CU_ASSERT(pbdev_found
== true);
963 CU_ASSERT(pbdev_found
== false);
966 if (raid_state
== RAID_BDEV_STATE_ONLINE
) {
967 TAILQ_FOREACH(pbdev
, &g_raid_bdev_configured_list
, state_link
) {
968 if (strcmp(pbdev
->bdev
.name
, r
->name
) == 0) {
973 } else if (raid_state
== RAID_BDEV_STATE_CONFIGURING
) {
974 TAILQ_FOREACH(pbdev
, &g_raid_bdev_configuring_list
, state_link
) {
975 if (strcmp(pbdev
->bdev
.name
, r
->name
) == 0) {
980 } else if (raid_state
== RAID_BDEV_STATE_OFFLINE
) {
981 TAILQ_FOREACH(pbdev
, &g_raid_bdev_offline_list
, state_link
) {
982 if (strcmp(pbdev
->bdev
.name
, r
->name
) == 0) {
988 if (presence
== true) {
989 CU_ASSERT(pbdev_found
== true);
991 CU_ASSERT(pbdev_found
== false);
996 spdk_bdev_queue_io_wait(struct spdk_bdev
*bdev
, struct spdk_io_channel
*ch
,
997 struct spdk_bdev_io_wait_entry
*entry
)
999 CU_ASSERT(bdev
== entry
->bdev
);
1000 CU_ASSERT(entry
->cb_fn
!= NULL
);
1001 CU_ASSERT(entry
->cb_arg
!= NULL
);
1002 TAILQ_INSERT_TAIL(&g_io_waitq
, entry
, link
);
1008 get_num_elts_in_waitq(void)
1010 struct spdk_bdev_io_wait_entry
*ele
;
1013 TAILQ_FOREACH(ele
, &g_io_waitq
, link
) {
1021 process_io_waitq(void)
1023 struct spdk_bdev_io_wait_entry
*ele
;
1024 struct spdk_bdev_io_wait_entry
*next_ele
;
1026 TAILQ_FOREACH_SAFE(ele
, &g_io_waitq
, link
, next_ele
) {
1027 TAILQ_REMOVE(&g_io_waitq
, ele
, link
);
1028 ele
->cb_fn(ele
->cb_arg
);
1033 verify_get_raids(struct rpc_construct_raid_bdev
*construct_req
,
1034 uint8_t g_max_raids
,
1035 char **g_get_raids_output
, uint32_t g_get_raids_count
)
1040 CU_ASSERT(g_max_raids
== g_get_raids_count
);
1041 if (g_max_raids
== g_get_raids_count
) {
1042 for (i
= 0; i
< g_max_raids
; i
++) {
1044 for (j
= 0; j
< g_max_raids
; j
++) {
1045 if (construct_req
[i
].name
&& strcmp(construct_req
[i
].name
, g_get_raids_output
[i
]) == 0) {
1050 CU_ASSERT(found
== true);
1056 create_base_bdevs(uint32_t bbdev_start_idx
)
1059 struct spdk_bdev
*base_bdev
;
1063 for (i
= 0; i
< g_max_base_drives
; i
++, bbdev_start_idx
++) {
1064 num_chars
= snprintf(name
, 16, "%s%u%s", "Nvme", bbdev_start_idx
, "n1");
1065 name
[num_chars
] = '\0';
1066 base_bdev
= calloc(1, sizeof(struct spdk_bdev
));
1067 SPDK_CU_ASSERT_FATAL(base_bdev
!= NULL
);
1068 base_bdev
->name
= strdup(name
);
1069 SPDK_CU_ASSERT_FATAL(base_bdev
->name
!= NULL
);
1070 base_bdev
->blocklen
= g_block_len
;
1071 base_bdev
->blockcnt
= BLOCK_CNT
;
1072 TAILQ_INSERT_TAIL(&g_bdev_list
, base_bdev
, internal
.link
);
1077 create_test_req(struct rpc_construct_raid_bdev
*r
, const char *raid_name
, uint32_t bbdev_start_idx
,
1078 bool create_base_bdev
)
1083 uint32_t bbdev_idx
= bbdev_start_idx
;
1085 r
->name
= strdup(raid_name
);
1086 SPDK_CU_ASSERT_FATAL(r
->name
!= NULL
);
1087 r
->strip_size_kb
= (g_strip_size
* g_block_len
) / 1024;
1089 r
->base_bdevs
.num_base_bdevs
= g_max_base_drives
;
1090 for (i
= 0; i
< g_max_base_drives
; i
++, bbdev_idx
++) {
1091 num_chars
= snprintf(name
, 16, "%s%u%s", "Nvme", bbdev_idx
, "n1");
1092 name
[num_chars
] = '\0';
1093 r
->base_bdevs
.base_bdevs
[i
] = strdup(name
);
1094 SPDK_CU_ASSERT_FATAL(r
->base_bdevs
.base_bdevs
[i
] != NULL
);
1096 if (create_base_bdev
== true) {
1097 create_base_bdevs(bbdev_start_idx
);
1102 free_test_req(struct rpc_construct_raid_bdev
*r
)
1107 for (i
= 0; i
< r
->base_bdevs
.num_base_bdevs
; i
++) {
1108 free(r
->base_bdevs
.base_bdevs
[i
]);
1113 test_construct_raid(void)
1115 struct rpc_construct_raid_bdev req
;
1116 struct rpc_destroy_raid_bdev destroy_req
;
1119 create_test_req(&req
, "raid1", 0, true);
1121 rpc_req_size
= sizeof(req
);
1122 CU_ASSERT(raid_bdev_init() == 0);
1124 verify_raid_config_present(req
.name
, false);
1125 verify_raid_bdev_present(req
.name
, false);
1127 g_json_decode_obj_construct
= 1;
1128 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1129 CU_ASSERT(g_rpc_err
== 0);
1130 verify_raid_config(&req
, true);
1131 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1132 free_test_req(&req
);
1134 destroy_req
.name
= strdup("raid1");
1135 rpc_req
= &destroy_req
;
1136 rpc_req_size
= sizeof(destroy_req
);
1138 g_json_decode_obj_construct
= 0;
1139 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1140 CU_ASSERT(g_rpc_err
== 0);
1142 base_bdevs_cleanup();
1147 test_destroy_raid(void)
1149 struct rpc_construct_raid_bdev construct_req
;
1150 struct rpc_destroy_raid_bdev destroy_req
;
1153 create_test_req(&construct_req
, "raid1", 0, true);
1154 rpc_req
= &construct_req
;
1155 rpc_req_size
= sizeof(construct_req
);
1156 CU_ASSERT(raid_bdev_init() == 0);
1157 verify_raid_config_present(construct_req
.name
, false);
1158 verify_raid_bdev_present(construct_req
.name
, false);
1160 g_json_decode_obj_construct
= 1;
1161 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1162 CU_ASSERT(g_rpc_err
== 0);
1163 verify_raid_config(&construct_req
, true);
1164 verify_raid_bdev(&construct_req
, true, RAID_BDEV_STATE_ONLINE
);
1165 free_test_req(&construct_req
);
1167 destroy_req
.name
= strdup("raid1");
1168 rpc_req
= &destroy_req
;
1169 rpc_req_size
= sizeof(destroy_req
);
1171 g_json_decode_obj_construct
= 0;
1172 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1173 CU_ASSERT(g_rpc_err
== 0);
1174 verify_raid_config_present("raid1", false);
1175 verify_raid_bdev_present("raid1", false);
1178 base_bdevs_cleanup();
1183 test_construct_raid_invalid_args(void)
1185 struct rpc_construct_raid_bdev req
;
1186 struct rpc_destroy_raid_bdev destroy_req
;
1187 struct raid_bdev_config
*raid_cfg
;
1191 rpc_req_size
= sizeof(req
);
1192 CU_ASSERT(raid_bdev_init() == 0);
1194 create_test_req(&req
, "raid1", 0, true);
1195 verify_raid_config_present(req
.name
, false);
1196 verify_raid_bdev_present(req
.name
, false);
1199 g_json_decode_obj_construct
= 1;
1200 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1201 CU_ASSERT(g_rpc_err
== 1);
1202 free_test_req(&req
);
1203 verify_raid_config_present("raid1", false);
1204 verify_raid_bdev_present("raid1", false);
1206 create_test_req(&req
, "raid1", 0, false);
1207 verify_raid_config_present(req
.name
, false);
1208 verify_raid_bdev_present(req
.name
, false);
1210 g_json_decode_obj_err
= 1;
1211 g_json_decode_obj_construct
= 1;
1212 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1213 CU_ASSERT(g_rpc_err
== 1);
1214 g_json_decode_obj_err
= 0;
1215 free_test_req(&req
);
1216 verify_raid_config_present("raid1", false);
1217 verify_raid_bdev_present("raid1", false);
1219 create_test_req(&req
, "raid1", 0, false);
1220 req
.strip_size_kb
= 1231;
1222 g_json_decode_obj_construct
= 1;
1223 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1224 CU_ASSERT(g_rpc_err
== 1);
1225 free_test_req(&req
);
1226 verify_raid_config_present("raid1", false);
1227 verify_raid_bdev_present("raid1", false);
1229 create_test_req(&req
, "raid1", 0, false);
1231 g_json_decode_obj_construct
= 1;
1232 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1233 CU_ASSERT(g_rpc_err
== 0);
1234 verify_raid_config(&req
, true);
1235 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1236 free_test_req(&req
);
1238 create_test_req(&req
, "raid1", 0, false);
1240 g_json_decode_obj_construct
= 1;
1241 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1242 CU_ASSERT(g_rpc_err
== 1);
1243 free_test_req(&req
);
1245 create_test_req(&req
, "raid2", 0, false);
1247 g_json_decode_obj_construct
= 1;
1248 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1249 CU_ASSERT(g_rpc_err
== 1);
1250 free_test_req(&req
);
1251 verify_raid_config_present("raid2", false);
1252 verify_raid_bdev_present("raid2", false);
1254 create_test_req(&req
, "raid2", g_max_base_drives
, true);
1255 free(req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1]);
1256 req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1] = strdup("Nvme0n1");
1257 SPDK_CU_ASSERT_FATAL(req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1] != NULL
);
1259 g_json_decode_obj_construct
= 1;
1260 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1261 CU_ASSERT(g_rpc_err
== 1);
1262 free_test_req(&req
);
1263 verify_raid_config_present("raid2", false);
1264 verify_raid_bdev_present("raid2", false);
1266 create_test_req(&req
, "raid2", g_max_base_drives
, true);
1267 free(req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1]);
1268 req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1] = strdup("Nvme100000n1");
1269 SPDK_CU_ASSERT_FATAL(req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1] != NULL
);
1271 g_json_decode_obj_construct
= 1;
1272 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1273 CU_ASSERT(g_rpc_err
== 0);
1274 free_test_req(&req
);
1275 verify_raid_config_present("raid2", true);
1276 verify_raid_bdev_present("raid2", true);
1277 raid_cfg
= raid_bdev_config_find_by_name("raid2");
1278 SPDK_CU_ASSERT_FATAL(raid_cfg
!= NULL
);
1279 check_and_remove_raid_bdev(raid_cfg
);
1280 raid_bdev_config_cleanup(raid_cfg
);
1282 create_test_req(&req
, "raid2", g_max_base_drives
, false);
1284 g_json_beg_res_ret_err
= 1;
1285 g_json_decode_obj_construct
= 1;
1286 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1287 CU_ASSERT(g_rpc_err
== 0);
1288 free_test_req(&req
);
1289 verify_raid_config_present("raid2", true);
1290 verify_raid_bdev_present("raid2", true);
1291 verify_raid_config_present("raid1", true);
1292 verify_raid_bdev_present("raid1", true);
1293 g_json_beg_res_ret_err
= 0;
1295 destroy_req
.name
= strdup("raid1");
1296 rpc_req
= &destroy_req
;
1297 rpc_req_size
= sizeof(destroy_req
);
1298 g_json_decode_obj_construct
= 0;
1299 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1300 destroy_req
.name
= strdup("raid2");
1301 rpc_req
= &destroy_req
;
1302 rpc_req_size
= sizeof(destroy_req
);
1303 g_json_decode_obj_construct
= 0;
1304 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1306 base_bdevs_cleanup();
1311 test_destroy_raid_invalid_args(void)
1313 struct rpc_construct_raid_bdev construct_req
;
1314 struct rpc_destroy_raid_bdev destroy_req
;
1317 create_test_req(&construct_req
, "raid1", 0, true);
1318 rpc_req
= &construct_req
;
1319 rpc_req_size
= sizeof(construct_req
);
1320 CU_ASSERT(raid_bdev_init() == 0);
1321 verify_raid_config_present(construct_req
.name
, false);
1322 verify_raid_bdev_present(construct_req
.name
, false);
1324 g_json_decode_obj_construct
= 1;
1325 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1326 CU_ASSERT(g_rpc_err
== 0);
1327 verify_raid_config(&construct_req
, true);
1328 verify_raid_bdev(&construct_req
, true, RAID_BDEV_STATE_ONLINE
);
1329 free_test_req(&construct_req
);
1331 destroy_req
.name
= strdup("raid2");
1332 rpc_req
= &destroy_req
;
1333 rpc_req_size
= sizeof(destroy_req
);
1335 g_json_decode_obj_construct
= 0;
1336 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1337 CU_ASSERT(g_rpc_err
== 1);
1339 destroy_req
.name
= strdup("raid1");
1341 g_json_decode_obj_err
= 1;
1342 g_json_decode_obj_construct
= 0;
1343 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1344 CU_ASSERT(g_rpc_err
== 1);
1345 g_json_decode_obj_err
= 0;
1347 free(destroy_req
.name
);
1348 verify_raid_config_present("raid1", true);
1349 verify_raid_bdev_present("raid1", true);
1351 destroy_req
.name
= strdup("raid1");
1352 rpc_req
= &destroy_req
;
1353 rpc_req_size
= sizeof(destroy_req
);
1355 g_json_decode_obj_construct
= 0;
1356 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1357 CU_ASSERT(g_rpc_err
== 0);
1358 verify_raid_config_present("raid1", false);
1359 verify_raid_bdev_present("raid1", false);
1362 base_bdevs_cleanup();
1367 test_io_channel(void)
1369 struct rpc_construct_raid_bdev req
;
1370 struct rpc_destroy_raid_bdev destroy_req
;
1371 struct raid_bdev
*pbdev
;
1372 struct raid_bdev_io_channel
*ch_ctx
;
1376 create_test_req(&req
, "raid1", 0, true);
1378 rpc_req_size
= sizeof(req
);
1379 CU_ASSERT(raid_bdev_init() == 0);
1381 verify_raid_config_present(req
.name
, false);
1382 verify_raid_bdev_present(req
.name
, false);
1384 g_json_decode_obj_construct
= 1;
1385 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1386 CU_ASSERT(g_rpc_err
== 0);
1387 verify_raid_config(&req
, true);
1388 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1390 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1391 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1395 CU_ASSERT(pbdev
!= NULL
);
1396 ch_ctx
= calloc(1, sizeof(struct raid_bdev_io_channel
));
1397 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1399 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1400 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1401 CU_ASSERT(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1403 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1404 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1405 free_test_req(&req
);
1407 destroy_req
.name
= strdup("raid1");
1408 rpc_req
= &destroy_req
;
1409 rpc_req_size
= sizeof(destroy_req
);
1411 g_json_decode_obj_construct
= 0;
1412 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1413 CU_ASSERT(g_rpc_err
== 0);
1414 verify_raid_config_present("raid1", false);
1415 verify_raid_bdev_present("raid1", false);
1419 base_bdevs_cleanup();
1426 struct rpc_construct_raid_bdev req
;
1427 struct rpc_destroy_raid_bdev destroy_req
;
1428 struct raid_bdev
*pbdev
;
1429 struct spdk_io_channel
*ch
;
1430 struct raid_bdev_io_channel
*ch_ctx
;
1432 struct spdk_bdev_io
*bdev_io
;
1437 create_test_req(&req
, "raid1", 0, true);
1439 rpc_req_size
= sizeof(req
);
1440 CU_ASSERT(raid_bdev_init() == 0);
1441 verify_raid_config_present(req
.name
, false);
1442 verify_raid_bdev_present(req
.name
, false);
1444 g_json_decode_obj_construct
= 1;
1445 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1446 CU_ASSERT(g_rpc_err
== 0);
1447 verify_raid_config(&req
, true);
1448 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1449 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1450 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1454 CU_ASSERT(pbdev
!= NULL
);
1455 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1456 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1457 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1458 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1460 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1461 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1462 CU_ASSERT(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1465 /* test 2 IO sizes based on global strip size set earlier */
1466 for (i
= 0; i
< 2; i
++) {
1467 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1468 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1469 io_len
= (g_strip_size
/ 2) << i
;
1470 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, SPDK_BDEV_IO_TYPE_WRITE
);
1471 lba
+= g_strip_size
;
1472 memset(g_io_output
, 0, ((g_max_io_size
/ g_strip_size
) + 1) * sizeof(struct io_output
));
1473 g_io_output_index
= 0;
1474 raid_bdev_submit_request(ch
, bdev_io
);
1475 verify_io(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1476 g_child_io_status_flag
);
1477 bdev_io_cleanup(bdev_io
);
1481 free_test_req(&req
);
1482 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1483 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1485 destroy_req
.name
= strdup("raid1");
1486 rpc_req
= &destroy_req
;
1487 rpc_req_size
= sizeof(destroy_req
);
1489 g_json_decode_obj_construct
= 0;
1490 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1491 CU_ASSERT(g_rpc_err
== 0);
1492 verify_raid_config_present("raid1", false);
1493 verify_raid_bdev_present("raid1", false);
1496 base_bdevs_cleanup();
1503 struct rpc_construct_raid_bdev req
;
1504 struct rpc_destroy_raid_bdev destroy_req
;
1505 struct raid_bdev
*pbdev
;
1506 struct spdk_io_channel
*ch
;
1507 struct raid_bdev_io_channel
*ch_ctx
;
1509 struct spdk_bdev_io
*bdev_io
;
1514 create_test_req(&req
, "raid1", 0, true);
1516 rpc_req_size
= sizeof(req
);
1517 CU_ASSERT(raid_bdev_init() == 0);
1518 verify_raid_config_present(req
.name
, false);
1519 verify_raid_bdev_present(req
.name
, false);
1521 g_json_decode_obj_construct
= 1;
1522 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1523 CU_ASSERT(g_rpc_err
== 0);
1524 verify_raid_config(&req
, true);
1525 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1526 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1527 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1531 CU_ASSERT(pbdev
!= NULL
);
1532 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1533 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1534 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1535 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1537 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1538 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1539 CU_ASSERT(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1541 free_test_req(&req
);
1543 /* test 2 IO sizes based on global strip size set earlier */
1545 for (i
= 0; i
< 2; i
++) {
1546 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1547 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1548 io_len
= (g_strip_size
/ 2) << i
;
1549 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, SPDK_BDEV_IO_TYPE_READ
);
1550 lba
+= g_strip_size
;
1551 memset(g_io_output
, 0, ((g_max_io_size
/ g_strip_size
) + 1) * sizeof(struct io_output
));
1552 g_io_output_index
= 0;
1553 raid_bdev_submit_request(ch
, bdev_io
);
1554 verify_io(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1555 g_child_io_status_flag
);
1556 bdev_io_cleanup(bdev_io
);
1560 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1561 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1563 destroy_req
.name
= strdup("raid1");
1564 rpc_req
= &destroy_req
;
1565 rpc_req_size
= sizeof(destroy_req
);
1567 g_json_decode_obj_construct
= 0;
1568 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1569 CU_ASSERT(g_rpc_err
== 0);
1570 verify_raid_config_present("raid1", false);
1571 verify_raid_bdev_present("raid1", false);
1574 base_bdevs_cleanup();
1579 raid_bdev_io_generate_by_strips(uint64_t n_strips
)
1583 uint64_t start_offset
;
1584 uint64_t end_offset
;
1585 uint64_t offsets_in_strip
[3];
1586 uint64_t start_bdev_idx
;
1587 uint64_t start_bdev_offset
;
1588 uint64_t start_bdev_idxs
[3];
1591 /* 3 different situations of offset in strip */
1592 offsets_in_strip
[0] = 0;
1593 offsets_in_strip
[1] = g_strip_size
>> 1;
1594 offsets_in_strip
[2] = g_strip_size
- 1;
1596 /* 3 different situations of start_bdev_idx */
1597 start_bdev_idxs
[0] = 0;
1598 start_bdev_idxs
[1] = g_max_base_drives
>> 1;
1599 start_bdev_idxs
[2] = g_max_base_drives
- 1;
1601 /* consider different offset in strip */
1602 for (i
= 0; i
< 3; i
++) {
1603 start_offset
= offsets_in_strip
[i
];
1604 for (j
= 0; j
< 3; j
++) {
1605 end_offset
= offsets_in_strip
[j
];
1606 if (n_strips
== 1 && start_offset
> end_offset
) {
1610 /* consider at which base_bdev lba is started. */
1611 for (l
= 0; l
< 3; l
++) {
1612 start_bdev_idx
= start_bdev_idxs
[l
];
1613 start_bdev_offset
= start_bdev_idx
* g_strip_size
;
1614 lba
= g_lba_offset
+ start_bdev_offset
+ start_offset
;
1615 nblocks
= (n_strips
- 1) * g_strip_size
+ end_offset
- start_offset
+ 1;
1617 g_io_ranges
[g_io_range_idx
].lba
= lba
;
1618 g_io_ranges
[g_io_range_idx
].nblocks
= nblocks
;
1620 SPDK_CU_ASSERT_FATAL(g_io_range_idx
< MAX_TEST_IO_RANGE
);
1628 raid_bdev_io_generate(void)
1631 uint64_t n_strips_span
= g_max_base_drives
;
1632 uint64_t n_strips_times
[5] = {g_max_base_drives
+ 1, g_max_base_drives
* 2 - 1, g_max_base_drives
* 2,
1633 g_max_base_drives
* 3, g_max_base_drives
* 4
1639 /* consider different number of strips from 1 to strips spanned base bdevs,
1640 * and even to times of strips spanned base bdevs
1642 for (n_strips
= 1; n_strips
< n_strips_span
; n_strips
++) {
1643 raid_bdev_io_generate_by_strips(n_strips
);
1646 for (i
= 0; i
< SPDK_COUNTOF(n_strips_times
); i
++) {
1647 n_strips
= n_strips_times
[i
];
1648 raid_bdev_io_generate_by_strips(n_strips
);
1655 struct rpc_construct_raid_bdev req
;
1656 struct rpc_destroy_raid_bdev destroy_req
;
1657 struct raid_bdev
*pbdev
;
1658 struct spdk_io_channel
*ch
;
1659 struct raid_bdev_io_channel
*ch_ctx
;
1661 struct spdk_bdev_io
*bdev_io
;
1667 create_test_req(&req
, "raid1", 0, true);
1669 rpc_req_size
= sizeof(req
);
1670 CU_ASSERT(raid_bdev_init() == 0);
1671 verify_raid_config_present(req
.name
, false);
1672 verify_raid_bdev_present(req
.name
, false);
1674 g_json_decode_obj_construct
= 1;
1675 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1676 CU_ASSERT(g_rpc_err
== 0);
1677 verify_raid_config(&req
, true);
1678 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1679 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1680 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1684 CU_ASSERT(pbdev
!= NULL
);
1685 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1686 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1687 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1688 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1690 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1691 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1692 SPDK_CU_ASSERT_FATAL(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1695 CU_ASSERT(raid_bdev_io_type_supported(pbdev
, SPDK_BDEV_IO_TYPE_UNMAP
) == true);
1696 CU_ASSERT(raid_bdev_io_type_supported(pbdev
, SPDK_BDEV_IO_TYPE_FLUSH
) == true);
1698 raid_bdev_io_generate();
1699 for (count
= 0; count
< g_io_range_idx
; count
++) {
1700 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1701 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1702 io_len
= g_io_ranges
[count
].nblocks
;
1703 lba
= g_io_ranges
[count
].lba
;
1704 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, SPDK_BDEV_IO_TYPE_UNMAP
);
1705 memset(g_io_output
, 0, g_max_base_drives
* sizeof(struct io_output
));
1706 g_io_output_index
= 0;
1707 raid_bdev_submit_request(ch
, bdev_io
);
1708 verify_io_without_payload(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1709 g_child_io_status_flag
);
1710 bdev_io_cleanup(bdev_io
);
1713 free_test_req(&req
);
1715 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1716 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1718 destroy_req
.name
= strdup("raid1");
1719 rpc_req
= &destroy_req
;
1720 rpc_req_size
= sizeof(destroy_req
);
1722 g_json_decode_obj_construct
= 0;
1723 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1724 CU_ASSERT(g_rpc_err
== 0);
1725 verify_raid_config_present("raid1", false);
1726 verify_raid_bdev_present("raid1", false);
1729 base_bdevs_cleanup();
1733 /* Test IO failures */
1735 test_io_failure(void)
1737 struct rpc_construct_raid_bdev req
;
1738 struct rpc_destroy_raid_bdev destroy_req
;
1739 struct raid_bdev
*pbdev
;
1740 struct spdk_io_channel
*ch
;
1741 struct raid_bdev_io_channel
*ch_ctx
;
1743 struct spdk_bdev_io
*bdev_io
;
1749 create_test_req(&req
, "raid1", 0, true);
1751 rpc_req_size
= sizeof(req
);
1752 CU_ASSERT(raid_bdev_init() == 0);
1753 verify_raid_config_present(req
.name
, false);
1754 verify_raid_bdev_present(req
.name
, false);
1756 g_json_decode_obj_construct
= 1;
1757 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1758 CU_ASSERT(g_rpc_err
== 0);
1759 verify_raid_config(&req
, true);
1760 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1761 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1762 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1766 CU_ASSERT(pbdev
!= NULL
);
1767 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1768 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1769 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1770 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1772 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1773 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1774 CU_ASSERT(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1776 free_test_req(&req
);
1779 for (count
= 0; count
< 1; count
++) {
1780 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1781 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1782 io_len
= (g_strip_size
/ 2) << count
;
1783 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, SPDK_BDEV_IO_TYPE_INVALID
);
1784 lba
+= g_strip_size
;
1785 memset(g_io_output
, 0, ((g_max_io_size
/ g_strip_size
) + 1) * sizeof(struct io_output
));
1786 g_io_output_index
= 0;
1787 raid_bdev_submit_request(ch
, bdev_io
);
1788 verify_io(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1790 bdev_io_cleanup(bdev_io
);
1796 g_child_io_status_flag
= false;
1797 for (count
= 0; count
< 1; count
++) {
1798 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1799 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1800 io_len
= (g_strip_size
/ 2) << count
;
1801 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, SPDK_BDEV_IO_TYPE_WRITE
);
1802 lba
+= g_strip_size
;
1803 memset(g_io_output
, 0, ((g_max_io_size
/ g_strip_size
) + 1) * sizeof(struct io_output
));
1804 g_io_output_index
= 0;
1805 raid_bdev_submit_request(ch
, bdev_io
);
1806 verify_io(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1807 g_child_io_status_flag
);
1808 bdev_io_cleanup(bdev_io
);
1812 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1813 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1815 destroy_req
.name
= strdup("raid1");
1816 rpc_req
= &destroy_req
;
1817 rpc_req_size
= sizeof(destroy_req
);
1819 g_json_decode_obj_construct
= 0;
1820 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1821 CU_ASSERT(g_rpc_err
== 0);
1822 verify_raid_config_present("raid1", false);
1823 verify_raid_bdev_present("raid1", false);
1826 base_bdevs_cleanup();
1834 struct rpc_construct_raid_bdev req
;
1835 struct rpc_destroy_raid_bdev destroy_req
;
1836 struct raid_bdev
*pbdev
;
1837 struct spdk_io_channel
*ch
;
1838 struct raid_bdev_io_channel
*ch_ctx
;
1840 struct spdk_bdev_io
*bdev_io
;
1843 create_test_req(&req
, "raid1", 0, true);
1845 rpc_req_size
= sizeof(req
);
1846 CU_ASSERT(raid_bdev_init() == 0);
1847 verify_raid_config_present(req
.name
, false);
1848 verify_raid_bdev_present(req
.name
, false);
1850 g_json_decode_obj_construct
= 1;
1851 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1852 CU_ASSERT(g_rpc_err
== 0);
1853 verify_raid_config(&req
, true);
1854 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1855 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1856 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1860 CU_ASSERT(pbdev
!= NULL
);
1861 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1862 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1863 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1864 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1866 SPDK_CU_ASSERT_FATAL(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1867 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1868 CU_ASSERT(ch_ctx
->base_channel
&& ch_ctx
->base_channel
[i
] == (void *)0x1);
1870 free_test_req(&req
);
1872 g_bdev_io_submit_status
= 0;
1873 g_child_io_status_flag
= true;
1875 CU_ASSERT(raid_bdev_io_type_supported(pbdev
, SPDK_BDEV_IO_TYPE_RESET
) == true);
1877 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1878 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1879 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, 0, 1, SPDK_BDEV_IO_TYPE_RESET
);
1880 memset(g_io_output
, 0, g_max_base_drives
* sizeof(struct io_output
));
1881 g_io_output_index
= 0;
1882 raid_bdev_submit_request(ch
, bdev_io
);
1883 verify_reset_io(bdev_io
, req
.base_bdevs
.num_base_bdevs
, ch_ctx
, pbdev
,
1885 bdev_io_cleanup(bdev_io
);
1888 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1889 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1891 destroy_req
.name
= strdup("raid1");
1892 rpc_req
= &destroy_req
;
1893 rpc_req_size
= sizeof(destroy_req
);
1895 g_json_decode_obj_construct
= 0;
1896 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1897 CU_ASSERT(g_rpc_err
== 0);
1898 verify_raid_config_present("raid1", false);
1899 verify_raid_bdev_present("raid1", false);
1902 base_bdevs_cleanup();
1906 /* Test waitq logic */
1910 struct rpc_construct_raid_bdev req
;
1911 struct rpc_destroy_raid_bdev destroy_req
;
1912 struct raid_bdev
*pbdev
;
1913 struct spdk_io_channel
*ch
;
1914 struct raid_bdev_io_channel
*ch_ctx
;
1916 struct spdk_bdev_io
*bdev_io
;
1917 struct spdk_bdev_io
*bdev_io_next
;
1920 TAILQ_HEAD(, spdk_bdev_io
) head_io
;
1923 create_test_req(&req
, "raid1", 0, true);
1925 rpc_req_size
= sizeof(req
);
1926 CU_ASSERT(raid_bdev_init() == 0);
1927 verify_raid_config_present(req
.name
, false);
1928 verify_raid_bdev_present(req
.name
, false);
1930 g_json_decode_obj_construct
= 1;
1931 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
1932 CU_ASSERT(g_rpc_err
== 0);
1933 verify_raid_config(&req
, true);
1934 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
1935 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
1936 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
1940 SPDK_CU_ASSERT_FATAL(pbdev
!= NULL
);
1941 ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
1942 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
1943 ch_ctx
= spdk_io_channel_get_ctx(ch
);
1944 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
1946 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
1947 SPDK_CU_ASSERT_FATAL(ch_ctx
->base_channel
!= NULL
);
1948 for (i
= 0; i
< req
.base_bdevs
.num_base_bdevs
; i
++) {
1949 CU_ASSERT(ch_ctx
->base_channel
[i
] == (void *)0x1);
1951 free_test_req(&req
);
1954 TAILQ_INIT(&head_io
);
1955 for (count
= 0; count
< 128; count
++) {
1956 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
1957 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
1958 TAILQ_INSERT_TAIL(&head_io
, bdev_io
, module_link
);
1959 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, 8, SPDK_BDEV_IO_TYPE_WRITE
);
1960 g_bdev_io_submit_status
= -ENOMEM
;
1961 lba
+= g_strip_size
;
1962 raid_bdev_submit_request(ch
, bdev_io
);
1965 g_ignore_io_output
= 1;
1967 count
= get_num_elts_in_waitq();
1968 CU_ASSERT(count
== 128);
1969 g_bdev_io_submit_status
= 0;
1971 CU_ASSERT(TAILQ_EMPTY(&g_io_waitq
));
1973 TAILQ_FOREACH_SAFE(bdev_io
, &head_io
, module_link
, bdev_io_next
) {
1974 bdev_io_cleanup(bdev_io
);
1978 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
1979 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
1980 g_ignore_io_output
= 0;
1982 destroy_req
.name
= strdup("raid1");
1983 rpc_req
= &destroy_req
;
1984 rpc_req_size
= sizeof(destroy_req
);
1986 g_json_decode_obj_construct
= 0;
1987 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
1988 CU_ASSERT(g_rpc_err
== 0);
1989 verify_raid_config_present("raid1", false);
1990 verify_raid_bdev_present("raid1", false);
1993 base_bdevs_cleanup();
1997 /* Create multiple raids, destroy raids without IO, get_raids related tests */
1999 test_multi_raid_no_io(void)
2001 struct rpc_construct_raid_bdev
*construct_req
;
2002 struct rpc_destroy_raid_bdev destroy_req
;
2003 struct rpc_get_raid_bdevs get_raids_req
;
2007 uint32_t bbdev_idx
= 0;
2010 construct_req
= calloc(MAX_RAIDS
, sizeof(struct rpc_construct_raid_bdev
));
2011 SPDK_CU_ASSERT_FATAL(construct_req
!= NULL
);
2012 CU_ASSERT(raid_bdev_init() == 0);
2013 for (i
= 0; i
< g_max_raids
; i
++) {
2014 count
= snprintf(name
, 16, "%s%u", "raid", i
);
2016 create_test_req(&construct_req
[i
], name
, bbdev_idx
, true);
2017 verify_raid_config_present(name
, false);
2018 verify_raid_bdev_present(name
, false);
2019 bbdev_idx
+= g_max_base_drives
;
2020 rpc_req
= &construct_req
[i
];
2021 rpc_req_size
= sizeof(construct_req
[0]);
2023 g_json_decode_obj_construct
= 1;
2024 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
2025 CU_ASSERT(g_rpc_err
== 0);
2026 verify_raid_config(&construct_req
[i
], true);
2027 verify_raid_bdev(&construct_req
[i
], true, RAID_BDEV_STATE_ONLINE
);
2030 get_raids_req
.category
= strdup("all");
2031 rpc_req
= &get_raids_req
;
2032 rpc_req_size
= sizeof(get_raids_req
);
2034 g_test_multi_raids
= 1;
2035 g_json_decode_obj_construct
= 0;
2036 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2037 CU_ASSERT(g_rpc_err
== 0);
2038 verify_get_raids(construct_req
, g_max_raids
, g_get_raids_output
, g_get_raids_count
);
2039 for (i
= 0; i
< g_get_raids_count
; i
++) {
2040 free(g_get_raids_output
[i
]);
2042 g_get_raids_count
= 0;
2044 get_raids_req
.category
= strdup("online");
2045 rpc_req
= &get_raids_req
;
2046 rpc_req_size
= sizeof(get_raids_req
);
2048 g_json_decode_obj_construct
= 0;
2049 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2050 CU_ASSERT(g_rpc_err
== 0);
2051 verify_get_raids(construct_req
, g_max_raids
, g_get_raids_output
, g_get_raids_count
);
2052 for (i
= 0; i
< g_get_raids_count
; i
++) {
2053 free(g_get_raids_output
[i
]);
2055 g_get_raids_count
= 0;
2057 get_raids_req
.category
= strdup("configuring");
2058 rpc_req
= &get_raids_req
;
2059 rpc_req_size
= sizeof(get_raids_req
);
2061 g_json_decode_obj_construct
= 0;
2062 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2063 CU_ASSERT(g_rpc_err
== 0);
2064 CU_ASSERT(g_get_raids_count
== 0);
2066 get_raids_req
.category
= strdup("offline");
2067 rpc_req
= &get_raids_req
;
2068 rpc_req_size
= sizeof(get_raids_req
);
2070 g_json_decode_obj_construct
= 0;
2071 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2072 CU_ASSERT(g_rpc_err
== 0);
2073 CU_ASSERT(g_get_raids_count
== 0);
2075 get_raids_req
.category
= strdup("invalid_category");
2076 rpc_req
= &get_raids_req
;
2077 rpc_req_size
= sizeof(get_raids_req
);
2079 g_json_decode_obj_construct
= 0;
2080 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2081 CU_ASSERT(g_rpc_err
== 1);
2082 CU_ASSERT(g_get_raids_count
== 0);
2084 get_raids_req
.category
= strdup("all");
2085 rpc_req
= &get_raids_req
;
2086 rpc_req_size
= sizeof(get_raids_req
);
2088 g_json_decode_obj_err
= 1;
2089 g_json_decode_obj_construct
= 0;
2090 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2091 CU_ASSERT(g_rpc_err
== 1);
2092 g_json_decode_obj_err
= 0;
2093 free(get_raids_req
.category
);
2094 CU_ASSERT(g_get_raids_count
== 0);
2096 get_raids_req
.category
= strdup("all");
2097 rpc_req
= &get_raids_req
;
2098 rpc_req_size
= sizeof(get_raids_req
);
2100 g_json_beg_res_ret_err
= 1;
2101 g_json_decode_obj_construct
= 0;
2102 spdk_rpc_get_raid_bdevs(NULL
, NULL
);
2103 CU_ASSERT(g_rpc_err
== 0);
2104 g_json_beg_res_ret_err
= 0;
2105 CU_ASSERT(g_get_raids_count
== 0);
2107 for (i
= 0; i
< g_max_raids
; i
++) {
2108 SPDK_CU_ASSERT_FATAL(construct_req
[i
].name
!= NULL
);
2109 destroy_req
.name
= strdup(construct_req
[i
].name
);
2110 count
= snprintf(name
, 16, "%s", destroy_req
.name
);
2112 rpc_req
= &destroy_req
;
2113 rpc_req_size
= sizeof(destroy_req
);
2115 g_json_decode_obj_construct
= 0;
2116 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
2117 CU_ASSERT(g_rpc_err
== 0);
2118 verify_raid_config_present(name
, false);
2119 verify_raid_bdev_present(name
, false);
2121 g_test_multi_raids
= 0;
2123 for (i
= 0; i
< g_max_raids
; i
++) {
2124 free_test_req(&construct_req
[i
]);
2126 free(construct_req
);
2127 base_bdevs_cleanup();
2131 /* Create multiple raids, fire IOs on raids */
2133 test_multi_raid_with_io(void)
2135 struct rpc_construct_raid_bdev
*construct_req
;
2136 struct rpc_destroy_raid_bdev destroy_req
;
2140 uint32_t bbdev_idx
= 0;
2141 struct raid_bdev
*pbdev
;
2142 struct spdk_io_channel
*ch
;
2143 struct raid_bdev_io_channel
*ch_ctx
;
2144 struct spdk_bdev_io
*bdev_io
;
2150 construct_req
= calloc(g_max_raids
, sizeof(struct rpc_construct_raid_bdev
));
2151 SPDK_CU_ASSERT_FATAL(construct_req
!= NULL
);
2152 CU_ASSERT(raid_bdev_init() == 0);
2153 ch
= calloc(g_max_raids
, sizeof(struct spdk_io_channel
) + sizeof(struct raid_bdev_io_channel
));
2154 SPDK_CU_ASSERT_FATAL(ch
!= NULL
);
2155 for (i
= 0; i
< g_max_raids
; i
++) {
2156 count
= snprintf(name
, 16, "%s%u", "raid", i
);
2158 create_test_req(&construct_req
[i
], name
, bbdev_idx
, true);
2159 verify_raid_config_present(name
, false);
2160 verify_raid_bdev_present(name
, false);
2161 bbdev_idx
+= g_max_base_drives
;
2162 rpc_req
= &construct_req
[i
];
2163 rpc_req_size
= sizeof(construct_req
[0]);
2165 g_json_decode_obj_construct
= 1;
2166 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
2167 CU_ASSERT(g_rpc_err
== 0);
2168 verify_raid_config(&construct_req
[i
], true);
2169 verify_raid_bdev(&construct_req
[i
], true, RAID_BDEV_STATE_ONLINE
);
2170 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
2171 if (strcmp(pbdev
->bdev
.name
, construct_req
[i
].name
) == 0) {
2175 CU_ASSERT(pbdev
!= NULL
);
2176 ch_ctx
= spdk_io_channel_get_ctx(&ch
[i
]);
2177 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
2178 CU_ASSERT(raid_bdev_create_cb(pbdev
, ch_ctx
) == 0);
2179 CU_ASSERT(ch_ctx
->base_channel
!= NULL
);
2180 for (j
= 0; j
< construct_req
[i
].base_bdevs
.num_base_bdevs
; j
++) {
2181 CU_ASSERT(ch_ctx
->base_channel
[j
] == (void *)0x1);
2185 /* This will perform a write on the first raid and a read on the second. It can be
2186 * expanded in the future to perform r/w on each raid device in the event that
2187 * multiple raid levels are supported.
2189 for (i
= 0; i
< g_max_raids
; i
++) {
2190 bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct raid_bdev_io
));
2191 SPDK_CU_ASSERT_FATAL(bdev_io
!= NULL
);
2192 io_len
= g_strip_size
;
2193 iotype
= (i
) ? SPDK_BDEV_IO_TYPE_WRITE
: SPDK_BDEV_IO_TYPE_READ
;
2194 memset(g_io_output
, 0, ((g_max_io_size
/ g_strip_size
) + 1) * sizeof(struct io_output
));
2195 g_io_output_index
= 0;
2196 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
2197 if (strcmp(pbdev
->bdev
.name
, construct_req
[i
].name
) == 0) {
2201 bdev_io_initialize(bdev_io
, &pbdev
->bdev
, lba
, io_len
, iotype
);
2202 CU_ASSERT(pbdev
!= NULL
);
2203 raid_bdev_submit_request(ch
, bdev_io
);
2204 verify_io(bdev_io
, g_max_base_drives
, ch_ctx
, pbdev
,
2205 g_child_io_status_flag
);
2206 bdev_io_cleanup(bdev_io
);
2210 for (i
= 0; i
< g_max_raids
; i
++) {
2211 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
2212 if (strcmp(pbdev
->bdev
.name
, construct_req
[i
].name
) == 0) {
2216 CU_ASSERT(pbdev
!= NULL
);
2217 ch_ctx
= spdk_io_channel_get_ctx(&ch
[i
]);
2218 SPDK_CU_ASSERT_FATAL(ch_ctx
!= NULL
);
2219 raid_bdev_destroy_cb(pbdev
, ch_ctx
);
2220 CU_ASSERT(ch_ctx
->base_channel
== NULL
);
2221 destroy_req
.name
= strdup(construct_req
[i
].name
);
2222 count
= snprintf(name
, 16, "%s", destroy_req
.name
);
2224 rpc_req
= &destroy_req
;
2225 rpc_req_size
= sizeof(destroy_req
);
2227 g_json_decode_obj_construct
= 0;
2228 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
2229 CU_ASSERT(g_rpc_err
== 0);
2230 verify_raid_config_present(name
, false);
2231 verify_raid_bdev_present(name
, false);
2234 for (i
= 0; i
< g_max_raids
; i
++) {
2235 free_test_req(&construct_req
[i
]);
2237 free(construct_req
);
2239 base_bdevs_cleanup();
2244 test_io_type_supported(void)
2246 CU_ASSERT(raid_bdev_io_type_supported(NULL
, SPDK_BDEV_IO_TYPE_READ
) == true);
2247 CU_ASSERT(raid_bdev_io_type_supported(NULL
, SPDK_BDEV_IO_TYPE_WRITE
) == true);
2248 CU_ASSERT(raid_bdev_io_type_supported(NULL
, SPDK_BDEV_IO_TYPE_INVALID
) == false);
2252 test_create_raid_from_config(void)
2254 struct rpc_construct_raid_bdev req
;
2255 struct spdk_bdev
*bdev
;
2256 struct rpc_destroy_raid_bdev destroy_req
;
2258 struct raid_bdev_config
*raid_cfg
;
2259 uint32_t base_bdev_slot
;
2262 create_test_req(&req
, "raid1", 0, true);
2264 rpc_req_size
= sizeof(req
);
2265 g_config_level_create
= 1;
2266 CU_ASSERT(raid_bdev_init() == 0);
2267 g_config_level_create
= 0;
2269 verify_raid_config_present("raid1", true);
2270 verify_raid_bdev_present("raid1", true);
2272 TAILQ_FOREACH(bdev
, &g_bdev_list
, internal
.link
) {
2273 raid_bdev_examine(bdev
);
2276 can_claim
= raid_bdev_can_claim_bdev("Invalid", &raid_cfg
, &base_bdev_slot
);
2277 CU_ASSERT(can_claim
== false);
2279 verify_raid_config(&req
, true);
2280 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
2282 destroy_req
.name
= strdup("raid1");
2283 rpc_req
= &destroy_req
;
2284 rpc_req_size
= sizeof(destroy_req
);
2286 g_json_decode_obj_construct
= 0;
2287 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
2288 CU_ASSERT(g_rpc_err
== 0);
2289 verify_raid_config_present("raid1", false);
2290 verify_raid_bdev_present("raid1", false);
2293 free_test_req(&req
);
2294 base_bdevs_cleanup();
2299 test_create_raid_from_config_invalid_params(void)
2301 struct rpc_construct_raid_bdev req
;
2306 rpc_req_size
= sizeof(req
);
2307 g_config_level_create
= 1;
2309 create_test_req(&req
, "raid1", 0, true);
2312 CU_ASSERT(raid_bdev_init() != 0);
2313 free_test_req(&req
);
2314 verify_raid_config_present("raid1", false);
2315 verify_raid_bdev_present("raid1", false);
2317 create_test_req(&req
, "raid1", 0, false);
2318 req
.strip_size_kb
= 1234;
2319 CU_ASSERT(raid_bdev_init() != 0);
2320 free_test_req(&req
);
2321 verify_raid_config_present("raid1", false);
2322 verify_raid_bdev_present("raid1", false);
2324 create_test_req(&req
, "raid1", 0, false);
2326 CU_ASSERT(raid_bdev_init() != 0);
2327 free_test_req(&req
);
2328 verify_raid_config_present("raid1", false);
2329 verify_raid_bdev_present("raid1", false);
2331 create_test_req(&req
, "raid1", 0, false);
2333 CU_ASSERT(raid_bdev_init() != 0);
2334 free_test_req(&req
);
2335 verify_raid_config_present("raid1", false);
2336 verify_raid_bdev_present("raid1", false);
2338 create_test_req(&req
, "raid1", 0, false);
2339 req
.base_bdevs
.num_base_bdevs
++;
2340 CU_ASSERT(raid_bdev_init() != 0);
2341 req
.base_bdevs
.num_base_bdevs
--;
2342 free_test_req(&req
);
2343 verify_raid_config_present("raid1", false);
2344 verify_raid_bdev_present("raid1", false);
2346 create_test_req(&req
, "raid1", 0, false);
2347 req
.base_bdevs
.num_base_bdevs
--;
2348 CU_ASSERT(raid_bdev_init() != 0);
2349 req
.base_bdevs
.num_base_bdevs
++;
2350 free_test_req(&req
);
2351 verify_raid_config_present("raid1", false);
2352 verify_raid_bdev_present("raid1", false);
2354 if (g_max_base_drives
> 1) {
2355 create_test_req(&req
, "raid1", 0, false);
2356 count
= snprintf(req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1], 15, "%s", "Nvme0n1");
2357 req
.base_bdevs
.base_bdevs
[g_max_base_drives
- 1][count
] = '\0';
2358 CU_ASSERT(raid_bdev_init() != 0);
2359 free_test_req(&req
);
2360 verify_raid_config_present("raid1", false);
2361 verify_raid_bdev_present("raid1", false);
2365 base_bdevs_cleanup();
2370 test_raid_json_dump_info(void)
2372 struct rpc_construct_raid_bdev req
;
2373 struct rpc_destroy_raid_bdev destroy_req
;
2374 struct raid_bdev
*pbdev
;
2377 create_test_req(&req
, "raid1", 0, true);
2379 rpc_req_size
= sizeof(req
);
2380 CU_ASSERT(raid_bdev_init() == 0);
2382 verify_raid_config_present(req
.name
, false);
2383 verify_raid_bdev_present(req
.name
, false);
2385 g_json_decode_obj_construct
= 1;
2386 spdk_rpc_construct_raid_bdev(NULL
, NULL
);
2387 CU_ASSERT(g_rpc_err
== 0);
2388 verify_raid_bdev(&req
, true, RAID_BDEV_STATE_ONLINE
);
2390 TAILQ_FOREACH(pbdev
, &g_raid_bdev_list
, global_link
) {
2391 if (strcmp(pbdev
->bdev
.name
, req
.name
) == 0) {
2395 CU_ASSERT(pbdev
!= NULL
);
2397 CU_ASSERT(raid_bdev_dump_info_json(pbdev
, NULL
) == 0);
2399 free_test_req(&req
);
2401 destroy_req
.name
= strdup("raid1");
2402 rpc_req
= &destroy_req
;
2403 rpc_req_size
= sizeof(destroy_req
);
2405 g_json_decode_obj_construct
= 0;
2406 spdk_rpc_destroy_raid_bdev(NULL
, NULL
);
2407 CU_ASSERT(g_rpc_err
== 0);
2408 verify_raid_config_present("raid1", false);
2409 verify_raid_bdev_present("raid1", false);
2412 base_bdevs_cleanup();
2417 test_context_size(void)
2419 CU_ASSERT(raid_bdev_get_ctx_size() == sizeof(struct raid_bdev_io
));
2422 int main(int argc
, char **argv
)
2424 CU_pSuite suite
= NULL
;
2425 unsigned int num_failures
;
2427 if (CU_initialize_registry() != CUE_SUCCESS
) {
2428 return CU_get_error();
2431 suite
= CU_add_suite("raid", NULL
, NULL
);
2432 if (suite
== NULL
) {
2433 CU_cleanup_registry();
2434 return CU_get_error();
2438 CU_add_test(suite
, "test_construct_raid", test_construct_raid
) == NULL
||
2439 CU_add_test(suite
, "test_destroy_raid", test_destroy_raid
) == NULL
||
2440 CU_add_test(suite
, "test_construct_raid_invalid_args", test_construct_raid_invalid_args
) == NULL
||
2441 CU_add_test(suite
, "test_destroy_raid_invalid_args", test_destroy_raid_invalid_args
) == NULL
||
2442 CU_add_test(suite
, "test_io_channel", test_io_channel
) == NULL
||
2443 CU_add_test(suite
, "test_reset_io", test_reset_io
) == NULL
||
2444 CU_add_test(suite
, "test_write_io", test_write_io
) == NULL
||
2445 CU_add_test(suite
, "test_read_io", test_read_io
) == NULL
||
2446 CU_add_test(suite
, "test_unmap_io", test_unmap_io
) == NULL
||
2447 CU_add_test(suite
, "test_io_failure", test_io_failure
) == NULL
||
2448 CU_add_test(suite
, "test_io_waitq", test_io_waitq
) == NULL
||
2449 CU_add_test(suite
, "test_multi_raid_no_io", test_multi_raid_no_io
) == NULL
||
2450 CU_add_test(suite
, "test_multi_raid_with_io", test_multi_raid_with_io
) == NULL
||
2451 CU_add_test(suite
, "test_io_type_supported", test_io_type_supported
) == NULL
||
2452 CU_add_test(suite
, "test_create_raid_from_config", test_create_raid_from_config
) == NULL
||
2453 CU_add_test(suite
, "test_create_raid_from_config_invalid_params",
2454 test_create_raid_from_config_invalid_params
) == NULL
||
2455 CU_add_test(suite
, "test_raid_json_dump_info", test_raid_json_dump_info
) == NULL
||
2456 CU_add_test(suite
, "test_context_size", test_context_size
) == NULL
2458 CU_cleanup_registry();
2459 return CU_get_error();
2462 CU_basic_set_mode(CU_BRM_VERBOSE
);
2464 CU_basic_run_tests();
2465 num_failures
= CU_get_number_of_failures();
2466 CU_cleanup_registry();
2467 return num_failures
;