Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk_internal/cunit.h"
10 : :
11 : : #include "spdk_internal/mock.h"
12 : : #include "thread/thread_internal.h"
13 : :
14 : : #include "nvmf/ctrlr_bdev.c"
15 : :
16 : : #include "spdk/bdev_module.h"
17 : :
18 : 4 : SPDK_LOG_REGISTER_COMPONENT(nvmf)
19 : :
20 [ - + - + ]: 16 : DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), -1);
21 : :
22 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test");
23 : :
24 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_get_physical_block_size, uint32_t,
25 : : (const struct spdk_bdev *bdev), 4096);
26 : :
27 [ # # # # ]: 0 : DEFINE_STUB(nvmf_ctrlr_process_admin_cmd, int, (struct spdk_nvmf_request *req), 0);
28 : :
29 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_comparev_blocks, int, (struct spdk_bdev_desc *desc,
30 : : struct spdk_io_channel *ch, struct iovec *iov, int iovcnt,
31 : : uint64_t offset_blocks, uint64_t num_blocks,
32 : : spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
33 : :
34 [ - + # # ]: 4 : DEFINE_STUB(spdk_bdev_readv_blocks_ext, int, (struct spdk_bdev_desc *desc,
35 : : struct spdk_io_channel *ch, struct iovec *iov, int iovcnt, uint64_t offset_blocks,
36 : : uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg,
37 : : struct spdk_bdev_ext_io_opts *opts), 0);
38 : :
39 [ - + # # ]: 4 : DEFINE_STUB(spdk_bdev_writev_blocks_ext, int, (struct spdk_bdev_desc *desc,
40 : : struct spdk_io_channel *ch, struct iovec *iov, int iovcnt, uint64_t offset_blocks,
41 : : uint64_t num_blocks, spdk_bdev_io_completion_cb cb, void *cb_arg,
42 : : struct spdk_bdev_ext_io_opts *opts), 0);
43 : :
44 [ - + # # ]: 16 : DEFINE_STUB(spdk_bdev_nvme_admin_passthru, int,
45 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
46 : : const struct spdk_nvme_cmd *cmd, void *buf, size_t nbytes,
47 : : spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
48 : :
49 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_abort, int,
50 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
51 : : void *bio_cb_arg, spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
52 : :
53 : 0 : DEFINE_STUB_V(spdk_bdev_io_get_iovec,
54 : : (struct spdk_bdev_io *bdev_io, struct iovec **iovp, int *iovcntp));
55 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_get_write_unit_size, uint32_t, (const struct spdk_bdev *bdev), 1);
56 : :
57 : : struct spdk_bdev_desc {
58 : : struct spdk_bdev *bdev;
59 : : };
60 : :
61 : : uint32_t
62 : 8 : spdk_bdev_get_optimal_io_boundary(const struct spdk_bdev *bdev)
63 : : {
64 : 8 : return bdev->optimal_io_boundary;
65 : : }
66 : :
67 : : uint32_t
68 : 16 : spdk_bdev_get_md_size(const struct spdk_bdev *bdev)
69 : : {
70 : 16 : return bdev->md_len;
71 : : }
72 : :
73 : : bool
74 : 8 : spdk_bdev_is_md_interleaved(const struct spdk_bdev *bdev)
75 : : {
76 [ + - - + : 8 : return (bdev->md_len != 0) && bdev->md_interleave;
- + ]
77 : : }
78 : :
79 : : /* We have to use the typedef in the function declaration to appease astyle. */
80 : : typedef enum spdk_dif_type spdk_dif_type_t;
81 : :
82 : : spdk_dif_type_t
83 : 12 : spdk_bdev_get_dif_type(const struct spdk_bdev *bdev)
84 : : {
85 [ + - ]: 12 : if (bdev->md_len != 0) {
86 : 12 : return bdev->dif_type;
87 : : } else {
88 : 0 : return SPDK_DIF_DISABLE;
89 : : }
90 : 3 : }
91 : :
92 : : bool
93 : 8 : spdk_bdev_is_dif_head_of_md(const struct spdk_bdev *bdev)
94 : : {
95 [ + + ]: 8 : if (spdk_bdev_get_dif_type(bdev) != SPDK_DIF_DISABLE) {
96 [ - + ]: 4 : return bdev->dif_is_head_of_md;
97 : : } else {
98 : 4 : return false;
99 : : }
100 : 2 : }
101 : :
102 : : uint32_t
103 : 4 : spdk_bdev_get_data_block_size(const struct spdk_bdev *bdev)
104 : : {
105 [ - + ]: 4 : if (spdk_bdev_is_md_interleaved(bdev)) {
106 : 0 : return bdev->blocklen - bdev->md_len;
107 : : } else {
108 : 4 : return bdev->blocklen;
109 : : }
110 : 1 : }
111 : :
112 : : uint16_t
113 : 8 : spdk_bdev_get_acwu(const struct spdk_bdev *bdev)
114 : : {
115 : 8 : return bdev->acwu;
116 : : }
117 : :
118 : : uint32_t
119 : 64 : spdk_bdev_get_block_size(const struct spdk_bdev *bdev)
120 : : {
121 : 64 : return bdev->blocklen;
122 : : }
123 : :
124 : : uint64_t
125 : 84 : spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev)
126 : : {
127 : 84 : return bdev->blockcnt;
128 : : }
129 : :
130 : : /* We have to use the typedef in the function declaration to appease astyle. */
131 : : typedef enum spdk_dif_pi_format spdk_dif_pi_format_t;
132 : :
133 : : spdk_dif_pi_format_t
134 : 0 : spdk_bdev_get_dif_pi_format(const struct spdk_bdev *bdev)
135 : : {
136 : 0 : return bdev->dif_pi_format;
137 : : }
138 : :
139 : : uint32_t
140 : 16 : spdk_bdev_desc_get_md_size(struct spdk_bdev_desc *desc)
141 : : {
142 : 16 : return spdk_bdev_get_md_size(desc->bdev);
143 : : }
144 : :
145 : : bool
146 : 4 : spdk_bdev_desc_is_md_interleaved(struct spdk_bdev_desc *desc)
147 : : {
148 : 4 : return spdk_bdev_is_md_interleaved(desc->bdev);
149 : : }
150 : :
151 : : /* We have to use the typedef in the function declaration to appease astyle. */
152 : : typedef enum spdk_dif_type spdk_dif_type_t;
153 : :
154 : : spdk_dif_type_t
155 : 4 : spdk_bdev_desc_get_dif_type(struct spdk_bdev_desc *desc)
156 : : {
157 : 4 : return spdk_bdev_get_dif_type(desc->bdev);
158 : : }
159 : :
160 : : bool
161 : 8 : spdk_bdev_desc_is_dif_head_of_md(struct spdk_bdev_desc *desc)
162 : : {
163 : 8 : return spdk_bdev_is_dif_head_of_md(desc->bdev);
164 : : }
165 : :
166 : : uint32_t
167 : 64 : spdk_bdev_desc_get_block_size(struct spdk_bdev_desc *desc)
168 : : {
169 : 64 : return spdk_bdev_get_block_size(desc->bdev);
170 : : }
171 : :
172 : : spdk_dif_pi_format_t
173 : 0 : spdk_bdev_desc_get_dif_pi_format(struct spdk_bdev_desc *desc)
174 : : {
175 : 0 : return spdk_bdev_get_dif_pi_format(desc->bdev);
176 : : }
177 : :
178 [ - + # # ]: 4 : DEFINE_STUB(spdk_bdev_comparev_and_writev_blocks, int,
179 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
180 : : struct iovec *compare_iov, int compare_iovcnt,
181 : : struct iovec *write_iov, int write_iovcnt,
182 : : uint64_t offset_blocks, uint64_t num_blocks,
183 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
184 : : 0);
185 : :
186 [ # # # # ]: 0 : DEFINE_STUB(nvmf_ctrlr_process_io_cmd, int, (struct spdk_nvmf_request *req), 0);
187 : :
188 : 0 : DEFINE_STUB_V(spdk_bdev_io_get_nvme_fused_status, (const struct spdk_bdev_io *bdev_io,
189 : : uint32_t *cdw0, int *cmp_sct, int *cmp_sc, int *wr_sct, int *wr_sc));
190 : :
191 [ - + - + ]: 8 : DEFINE_STUB(spdk_bdev_desc_is_dif_check_enabled, bool,
192 : : (struct spdk_bdev_desc *desc, enum spdk_dif_check_type check_type), false);
193 : :
194 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *,
195 : : (struct spdk_bdev_desc *desc), NULL);
196 : :
197 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_flush_blocks, int,
198 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
199 : : uint64_t offset_blocks, uint64_t num_blocks,
200 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
201 : : 0);
202 : :
203 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_unmap_blocks, int,
204 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
205 : : uint64_t offset_blocks, uint64_t num_blocks,
206 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
207 : : 0);
208 : :
209 [ - + - + ]: 12 : DEFINE_STUB(spdk_bdev_io_type_supported, bool,
210 : : (struct spdk_bdev *bdev, enum spdk_bdev_io_type io_type), false);
211 : :
212 [ - + - + ]: 8 : DEFINE_STUB(spdk_bdev_queue_io_wait, int,
213 : : (struct spdk_bdev *bdev, struct spdk_io_channel *ch,
214 : : struct spdk_bdev_io_wait_entry *entry),
215 : : 0);
216 : :
217 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_write_blocks, int,
218 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, void *buf,
219 : : uint64_t offset_blocks, uint64_t num_blocks,
220 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
221 : : 0);
222 : :
223 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_writev_blocks, int,
224 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
225 : : struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
226 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
227 : : 0);
228 : :
229 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_read_blocks, int,
230 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, void *buf,
231 : : uint64_t offset_blocks, uint64_t num_blocks,
232 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
233 : : 0);
234 : :
235 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_readv_blocks, int,
236 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
237 : : struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks,
238 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
239 : : 0);
240 : :
241 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int,
242 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
243 : : uint64_t offset_blocks, uint64_t num_blocks,
244 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
245 : : 0);
246 : :
247 [ - + # # ]: 16 : DEFINE_STUB(spdk_bdev_nvme_iov_passthru_md, int, (
248 : : struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
249 : : const struct spdk_nvme_cmd *cmd, struct iovec *iov, int iovcnt,
250 : : size_t nbytes, void *md_buf, size_t md_len,
251 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
252 : : 0);
253 : :
254 : 16 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
255 : :
256 [ # # # # ]: 0 : DEFINE_STUB(spdk_nvmf_subsystem_get_nqn, const char *,
257 : : (const struct spdk_nvmf_subsystem *subsystem), NULL);
258 : :
259 [ - + # # ]: 4 : DEFINE_STUB(spdk_bdev_zcopy_start, int,
260 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
261 : : struct iovec *iov, int iovcnt,
262 : : uint64_t offset_blocks, uint64_t num_blocks,
263 : : bool populate,
264 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
265 : : 0);
266 : :
267 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_zcopy_end, int,
268 : : (struct spdk_bdev_io *bdev_io, bool commit,
269 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
270 : : 0);
271 : :
272 [ - + # # ]: 12 : DEFINE_STUB(spdk_bdev_copy_blocks, int,
273 : : (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
274 : : uint64_t dst_offset_blocks, uint64_t src_offset_blocks, uint64_t num_blocks,
275 : : spdk_bdev_io_completion_cb cb, void *cb_arg),
276 : : 0);
277 : :
278 [ - + # # ]: 8 : DEFINE_STUB(spdk_bdev_get_max_copy, uint32_t, (const struct spdk_bdev *bdev), 0);
279 : :
280 : : struct spdk_nvmf_ns *
281 : 0 : spdk_nvmf_subsystem_get_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid)
282 : : {
283 : 0 : abort();
284 : : return NULL;
285 : : }
286 : :
287 : : struct spdk_nvmf_ns *
288 : 0 : spdk_nvmf_subsystem_get_first_ns(struct spdk_nvmf_subsystem *subsystem)
289 : : {
290 : 0 : abort();
291 : : return NULL;
292 : : }
293 : :
294 : : struct spdk_nvmf_ns *
295 : 0 : spdk_nvmf_subsystem_get_next_ns(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns)
296 : : {
297 : 0 : abort();
298 : : return NULL;
299 : : }
300 : :
301 : : int
302 : 4 : spdk_dif_ctx_init(struct spdk_dif_ctx *ctx, uint32_t block_size, uint32_t md_size,
303 : : bool md_interleave, bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
304 : : uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag,
305 : : uint32_t data_offset, uint64_t guard_seed, struct spdk_dif_ctx_init_ext_opts *opts)
306 : : {
307 : 4 : ctx->dif_pi_format = opts->dif_pi_format;
308 : 4 : ctx->block_size = block_size;
309 : 4 : ctx->md_size = md_size;
310 : 4 : ctx->init_ref_tag = init_ref_tag;
311 : :
312 : 4 : return 0;
313 : : }
314 : :
315 : : static uint32_t g_bdev_nvme_status_cdw0;
316 : : static uint32_t g_bdev_nvme_status_sct = SPDK_NVME_SCT_GENERIC;
317 : : static uint32_t g_bdev_nvme_status_sc = SPDK_NVME_SC_SUCCESS;
318 : :
319 : : static void
320 : 8 : reset_bdev_nvme_status(void)
321 : : {
322 : 8 : g_bdev_nvme_status_cdw0 = 0;
323 : 8 : g_bdev_nvme_status_sct = SPDK_NVME_SCT_GENERIC;
324 : 8 : g_bdev_nvme_status_sc = SPDK_NVME_SC_SUCCESS;
325 : 8 : }
326 : :
327 : : void
328 : 16 : spdk_bdev_io_get_nvme_status(const struct spdk_bdev_io *bdev_io, uint32_t *cdw0, int *sct,
329 : : int *sc)
330 : : {
331 : 16 : *cdw0 = g_bdev_nvme_status_cdw0;
332 : 16 : *sct = g_bdev_nvme_status_sct;
333 : 16 : *sc = g_bdev_nvme_status_sc;
334 : 16 : }
335 : :
336 : : bool
337 : 8 : nvmf_ns_is_ptpl_capable(const struct spdk_nvmf_ns *ns)
338 : : {
339 : 8 : return ns->ptpl_file != NULL;
340 : : }
341 : :
342 : : static void
343 : 4 : test_get_rw_params(void)
344 : : {
345 : 4 : struct spdk_nvme_cmd cmd = {0};
346 : 3 : uint64_t lba;
347 : 3 : uint64_t count;
348 : :
349 : 4 : lba = 0;
350 : 4 : count = 0;
351 : 4 : to_le64(&cmd.cdw10, 0x1234567890ABCDEF);
352 : 4 : to_le32(&cmd.cdw12, 0x9875 | SPDK_NVME_IO_FLAGS_FORCE_UNIT_ACCESS);
353 : 4 : nvmf_bdev_ctrlr_get_rw_params(&cmd, &lba, &count);
354 : 4 : CU_ASSERT(lba == 0x1234567890ABCDEF);
355 : 4 : CU_ASSERT(count == 0x9875 + 1); /* NOTE: this field is 0's based, hence the +1 */
356 : 4 : }
357 : :
358 : : static void
359 : 4 : test_get_rw_ext_params(void)
360 : : {
361 : 4 : struct spdk_nvme_cmd cmd = {0};
362 : 4 : struct spdk_bdev_ext_io_opts opts = {0};
363 : :
364 : 4 : to_le32(&cmd.cdw12, 0x9875 | SPDK_NVME_IO_FLAGS_DATA_PLACEMENT_DIRECTIVE |
365 : : SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
366 : 4 : to_le32(&cmd.cdw13, 0x2 << 16);
367 : 4 : nvmf_bdev_ctrlr_get_rw_ext_params(&cmd, &opts);
368 : 4 : CU_ASSERT(opts.nvme_cdw12.raw == 0x10209875);
369 : 4 : CU_ASSERT(opts.nvme_cdw13.raw == 0x20000);
370 : 4 : CU_ASSERT((opts.dif_check_flags_exclude_mask ^ SPDK_NVME_IO_FLAGS_PRCHK_MASK)
371 : : == SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
372 : 4 : }
373 : :
374 : : static void
375 : 4 : test_lba_in_range(void)
376 : : {
377 : : /* Trivial cases (no overflow) */
378 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1) == true);
379 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1000) == true);
380 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1001) == false);
381 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1, 999) == true);
382 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1, 1000) == false);
383 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 999, 1) == true);
384 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1000, 1) == false);
385 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1001, 1) == false);
386 : :
387 : : /* Overflow edge cases */
388 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, 0, UINT64_MAX) == true);
389 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, 1, UINT64_MAX) == false);
390 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, UINT64_MAX - 1, 1) == true);
391 : 4 : CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, UINT64_MAX, 1) == false);
392 : 4 : }
393 : :
394 : : static void
395 : 4 : test_get_dif_ctx(void)
396 : : {
397 : 4 : struct spdk_bdev bdev = {};
398 : 4 : struct spdk_bdev_desc desc = { .bdev = &bdev, };
399 : 4 : struct spdk_nvme_cmd cmd = {};
400 : 4 : struct spdk_dif_ctx dif_ctx = {};
401 : : bool ret;
402 : :
403 : 4 : bdev.md_len = 0;
404 : :
405 : 4 : ret = nvmf_bdev_ctrlr_get_dif_ctx(&desc, &cmd, &dif_ctx);
406 : 4 : CU_ASSERT(ret == false);
407 : :
408 : 4 : to_le64(&cmd.cdw10, 0x1234567890ABCDEF);
409 : 4 : bdev.blocklen = 520;
410 : 4 : bdev.md_len = 8;
411 : :
412 : 4 : ret = nvmf_bdev_ctrlr_get_dif_ctx(&desc, &cmd, &dif_ctx);
413 : 4 : CU_ASSERT(ret == true);
414 : 4 : CU_ASSERT(dif_ctx.block_size == 520);
415 : 4 : CU_ASSERT(dif_ctx.md_size == 8);
416 : 4 : CU_ASSERT(dif_ctx.init_ref_tag == 0x90ABCDEF);
417 : 4 : }
418 : :
419 : : static void
420 : 4 : test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd(void)
421 : : {
422 : : int rc;
423 : 4 : struct spdk_bdev bdev = {};
424 : 4 : struct spdk_bdev_desc desc = { .bdev = &bdev, };
425 : 4 : struct spdk_io_channel ch = {};
426 : :
427 : 4 : struct spdk_nvmf_request cmp_req = {};
428 : 4 : union nvmf_c2h_msg cmp_rsp = {};
429 : :
430 : 4 : struct spdk_nvmf_request write_req = {};
431 : 4 : union nvmf_c2h_msg write_rsp = {};
432 : :
433 : 4 : struct spdk_nvmf_qpair qpair = {};
434 : :
435 : 4 : struct spdk_nvme_cmd cmp_cmd = {};
436 : 4 : struct spdk_nvme_cmd write_cmd = {};
437 : :
438 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
439 : 4 : struct spdk_nvmf_subsystem subsystem = {};
440 : 4 : struct spdk_nvmf_ns ns = {};
441 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
442 : :
443 : 4 : struct spdk_nvmf_poll_group group = {};
444 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
445 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
446 : :
447 : 4 : bdev.blocklen = 512;
448 : 4 : bdev.blockcnt = 10;
449 : 4 : ns.bdev = &bdev;
450 : :
451 : 4 : subsystem.id = 0;
452 : 4 : subsystem.max_nsid = 1;
453 : 4 : subsys_ns[0] = &ns;
454 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
455 : :
456 : : /* Enable controller */
457 : 4 : ctrlr.vcprop.cc.bits.en = 1;
458 : 4 : ctrlr.subsys = &subsystem;
459 : :
460 : 4 : group.num_sgroups = 1;
461 : 4 : sgroups.num_ns = 1;
462 : 4 : sgroups.ns_info = &ns_info;
463 : 4 : group.sgroups = &sgroups;
464 : :
465 : 4 : qpair.ctrlr = &ctrlr;
466 : 4 : qpair.group = &group;
467 : :
468 : 4 : cmp_req.qpair = &qpair;
469 : 4 : cmp_req.cmd = (union nvmf_h2c_msg *)&cmp_cmd;
470 : 4 : cmp_req.rsp = &cmp_rsp;
471 : :
472 : 4 : cmp_cmd.nsid = 1;
473 : 4 : cmp_cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST;
474 : 4 : cmp_cmd.opc = SPDK_NVME_OPC_COMPARE;
475 : :
476 : 4 : write_req.qpair = &qpair;
477 : 4 : write_req.cmd = (union nvmf_h2c_msg *)&write_cmd;
478 : 4 : write_req.rsp = &write_rsp;
479 : :
480 : 4 : write_cmd.nsid = 1;
481 : 4 : write_cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND;
482 : 4 : write_cmd.opc = SPDK_NVME_OPC_WRITE;
483 : :
484 : : /* 1. SUCCESS */
485 : 4 : cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
486 : 4 : cmp_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
487 : :
488 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
489 : 4 : write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
490 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen;
491 : :
492 : 4 : rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, &desc, &ch, &cmp_req, &write_req);
493 : :
494 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
495 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0);
496 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0);
497 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sct == 0);
498 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sc == 0);
499 : :
500 : : /* 2. Fused command start lba / num blocks mismatch */
501 : 4 : cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
502 : 4 : cmp_cmd.cdw12 = 2; /* NLB: CDW12 bits 15:00, 0's based */
503 : :
504 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
505 : 4 : write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
506 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen;
507 : :
508 : 4 : rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, &desc, &ch, &cmp_req, &write_req);
509 : :
510 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
511 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0);
512 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0);
513 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
514 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
515 : :
516 : : /* 3. SPDK_NVME_SC_LBA_OUT_OF_RANGE */
517 : 4 : cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
518 : 4 : cmp_cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */
519 : :
520 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
521 : 4 : write_cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */
522 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen;
523 : :
524 : 4 : rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, &desc, &ch, &cmp_req, &write_req);
525 : :
526 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
527 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0);
528 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0);
529 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
530 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_LBA_OUT_OF_RANGE);
531 : :
532 : : /* 4. SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID */
533 : 4 : cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
534 : 4 : cmp_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
535 : :
536 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
537 : 4 : write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
538 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen - 1;
539 : :
540 : 4 : rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, &desc, &ch, &cmp_req, &write_req);
541 : :
542 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
543 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0);
544 : 4 : CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0);
545 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
546 : 4 : CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID);
547 : 4 : }
548 : :
549 : : static void
550 : 4 : test_nvmf_bdev_ctrlr_identify_ns(void)
551 : : {
552 : 4 : struct spdk_nvmf_ns ns = {};
553 : 4 : struct spdk_nvme_ns_data nsdata = {};
554 : 4 : struct spdk_bdev bdev = {};
555 : 4 : struct spdk_bdev_desc desc = {};
556 : 4 : uint8_t ns_g_id[16] = "abcdefgh";
557 : 4 : uint8_t eui64[8] = "12345678";
558 : :
559 : 4 : desc.bdev = &bdev;
560 : 4 : ns.desc = &desc;
561 : 4 : ns.bdev = &bdev;
562 : 4 : ns.ptpl_file = (void *)0xDEADBEEF;
563 : 4 : memcpy(ns.opts.nguid, ns_g_id, 16);
564 : 4 : memcpy(ns.opts.eui64, eui64, 8);
565 : :
566 : 4 : bdev.blockcnt = 10;
567 : 4 : bdev.acwu = 1;
568 : 4 : bdev.md_len = 512;
569 : 4 : bdev.dif_type = SPDK_DIF_TYPE1;
570 : 4 : bdev.blocklen = 4096;
571 : 4 : bdev.md_interleave = 0;
572 : 4 : bdev.optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
573 : 4 : bdev.dif_is_head_of_md = true;
574 : :
575 : 4 : nvmf_bdev_ctrlr_identify_ns(&ns, &nsdata, false);
576 : 4 : CU_ASSERT(nsdata.nsze == 10);
577 : 4 : CU_ASSERT(nsdata.ncap == 10);
578 : 4 : CU_ASSERT(nsdata.nuse == 10);
579 : 4 : CU_ASSERT(nsdata.nlbaf == 0);
580 : 4 : CU_ASSERT(nsdata.flbas.format == 0);
581 : 4 : CU_ASSERT(nsdata.flbas.msb_format == 0);
582 : 4 : CU_ASSERT(nsdata.nacwu == 0);
583 : 4 : CU_ASSERT(nsdata.lbaf[0].lbads == spdk_u32log2(4096));
584 : 4 : CU_ASSERT(nsdata.lbaf[0].ms == 512);
585 : 4 : CU_ASSERT(nsdata.dps.pit == SPDK_NVME_FMT_NVM_PROTECTION_DISABLE);
586 : 4 : CU_ASSERT(nsdata.noiob == SPDK_BDEV_IO_NUM_CHILD_IOV);
587 : 4 : CU_ASSERT(nsdata.nmic.can_share == 1);
588 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.persist == 1);
589 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive == 1);
590 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access == 1);
591 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive_reg_only == 1);
592 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access_reg_only == 1);
593 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive_all_reg == 1);
594 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access_all_reg == 1);
595 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.ignore_existing_key == 1);
596 : 4 : CU_ASSERT(nsdata.flbas.extended == 1);
597 : 4 : CU_ASSERT(nsdata.mc.extended == 1);
598 : 4 : CU_ASSERT(nsdata.mc.pointer == 0);
599 : 4 : CU_ASSERT(nsdata.dps.md_start == true);
600 : 4 : CU_ASSERT(!strncmp(nsdata.nguid, ns_g_id, 16));
601 : 4 : CU_ASSERT(!strncmp((uint8_t *)&nsdata.eui64, eui64, 8));
602 : :
603 : 4 : memset(&nsdata, 0, sizeof(nsdata));
604 : 4 : nvmf_bdev_ctrlr_identify_ns(&ns, &nsdata, true);
605 : 4 : CU_ASSERT(nsdata.nsze == 10);
606 : 4 : CU_ASSERT(nsdata.ncap == 10);
607 : 4 : CU_ASSERT(nsdata.nuse == 10);
608 : 4 : CU_ASSERT(nsdata.nlbaf == 0);
609 : 4 : CU_ASSERT(nsdata.flbas.format == 0);
610 : 4 : CU_ASSERT(nsdata.flbas.msb_format == 0);
611 : 4 : CU_ASSERT(nsdata.nacwu == 0);
612 : 4 : CU_ASSERT(nsdata.lbaf[0].lbads == spdk_u32log2(4096));
613 : 4 : CU_ASSERT(nsdata.noiob == SPDK_BDEV_IO_NUM_CHILD_IOV);
614 : 4 : CU_ASSERT(nsdata.nmic.can_share == 1);
615 : 4 : CU_ASSERT(nsdata.lbaf[0].ms == 0);
616 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.persist == 1);
617 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive == 1);
618 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access == 1);
619 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive_reg_only == 1);
620 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access_reg_only == 1);
621 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.write_exclusive_all_reg == 1);
622 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.exclusive_access_all_reg == 1);
623 : 4 : CU_ASSERT(nsdata.nsrescap.rescap.ignore_existing_key == 1);
624 : 4 : CU_ASSERT(!strncmp(nsdata.nguid, ns_g_id, 16));
625 : 4 : CU_ASSERT(!strncmp((uint8_t *)&nsdata.eui64, eui64, 8));
626 : 4 : }
627 : :
628 : : static void
629 : 4 : test_nvmf_bdev_ctrlr_zcopy_start(void)
630 : : {
631 : : int rc;
632 : 4 : struct spdk_bdev bdev = {};
633 : 4 : struct spdk_bdev_desc desc = { .bdev = &bdev, };
634 : 4 : struct spdk_io_channel ch = {};
635 : :
636 : 4 : struct spdk_nvmf_request write_req = {};
637 : 4 : union nvmf_c2h_msg write_rsp = {};
638 : :
639 : 4 : struct spdk_nvmf_qpair qpair = {};
640 : :
641 : 4 : struct spdk_nvme_cmd write_cmd = {};
642 : :
643 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
644 : 4 : struct spdk_nvmf_subsystem subsystem = {};
645 : 4 : struct spdk_nvmf_ns ns = {};
646 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
647 : :
648 : 4 : struct spdk_nvmf_poll_group group = {};
649 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
650 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
651 : :
652 : 4 : bdev.blocklen = 512;
653 : 4 : bdev.blockcnt = 10;
654 : 4 : ns.bdev = &bdev;
655 : :
656 : 4 : subsystem.id = 0;
657 : 4 : subsystem.max_nsid = 1;
658 : 4 : subsys_ns[0] = &ns;
659 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
660 : :
661 : : /* Enable controller */
662 : 4 : ctrlr.vcprop.cc.bits.en = 1;
663 : 4 : ctrlr.subsys = &subsystem;
664 : :
665 : 4 : group.num_sgroups = 1;
666 : 4 : sgroups.num_ns = 1;
667 : 4 : sgroups.ns_info = &ns_info;
668 : 4 : group.sgroups = &sgroups;
669 : :
670 : 4 : qpair.ctrlr = &ctrlr;
671 : 4 : qpair.group = &group;
672 : :
673 : 4 : write_req.qpair = &qpair;
674 : 4 : write_req.cmd = (union nvmf_h2c_msg *)&write_cmd;
675 : 4 : write_req.rsp = &write_rsp;
676 : :
677 : 4 : write_cmd.nsid = 1;
678 : 4 : write_cmd.opc = SPDK_NVME_OPC_WRITE;
679 : :
680 : : /* 1. SUCCESS */
681 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
682 : 4 : write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
683 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen;
684 : :
685 : 4 : rc = nvmf_bdev_ctrlr_zcopy_start(&bdev, &desc, &ch, &write_req);
686 : :
687 : 4 : CU_ASSERT_EQUAL(rc, SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
688 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
689 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sc, SPDK_NVME_SC_SUCCESS);
690 : :
691 : : /* 2. SPDK_NVME_SC_LBA_OUT_OF_RANGE */
692 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
693 : 4 : write_cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */
694 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen;
695 : :
696 : 4 : rc = nvmf_bdev_ctrlr_zcopy_start(&bdev, &desc, &ch, &write_req);
697 : :
698 : 4 : CU_ASSERT_EQUAL(rc, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
699 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
700 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sc, SPDK_NVME_SC_LBA_OUT_OF_RANGE);
701 : :
702 : : /* 3. SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID */
703 : 4 : write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
704 : 4 : write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
705 : 4 : write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen - 1;
706 : :
707 : 4 : rc = nvmf_bdev_ctrlr_zcopy_start(&bdev, &desc, &ch, &write_req);
708 : :
709 : 4 : CU_ASSERT_EQUAL(rc, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
710 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
711 : 4 : CU_ASSERT_EQUAL(write_rsp.nvme_cpl.status.sc, SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID);
712 : 4 : }
713 : :
714 : : static void
715 : 4 : test_nvmf_bdev_ctrlr_cmd(void)
716 : : {
717 : : int rc;
718 : 4 : struct spdk_bdev bdev = {};
719 : 4 : struct spdk_bdev_desc desc = { .bdev = &bdev, };
720 : 4 : struct spdk_io_channel ch = {};
721 : 4 : struct spdk_nvmf_request req = {};
722 : 4 : struct spdk_nvmf_qpair qpair = {};
723 : 4 : union nvmf_h2c_msg cmd = {};
724 : 4 : union nvmf_c2h_msg rsp = {};
725 : 4 : struct spdk_nvme_scc_source_range range = {};
726 : :
727 : 4 : req.cmd = &cmd;
728 : 4 : req.rsp = &rsp;
729 : 4 : req.qpair = &qpair;
730 : 4 : req.length = 4096;
731 : 4 : bdev.blocklen = 512;
732 : 4 : bdev.blockcnt = 3;
733 : 4 : cmd.nvme_cmd.cdw10 = 0;
734 : 4 : cmd.nvme_cmd.cdw12 = 2;
735 : :
736 : : /* Compare status asynchronous */
737 : 4 : rc = nvmf_bdev_ctrlr_compare_cmd(&bdev, &desc, &ch, &req);
738 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
739 : :
740 : : /* SLBA out of range */
741 : 4 : cmd.nvme_cmd.cdw10 = 3;
742 : :
743 : 4 : rc = nvmf_bdev_ctrlr_compare_cmd(&bdev, &desc, &ch, &req);
744 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
745 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
746 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_LBA_OUT_OF_RANGE);
747 : :
748 : : /* SGL length invalid */
749 : 4 : cmd.nvme_cmd.cdw10 = 0;
750 : 4 : req.length = 512;
751 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
752 : :
753 : 4 : rc = nvmf_bdev_ctrlr_compare_cmd(&bdev, &desc, &ch, &req);
754 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
755 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
756 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID);
757 : :
758 : : /* Device error */
759 : 4 : req.length = 4096;
760 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
761 : 4 : MOCK_SET(spdk_bdev_comparev_blocks, -1);
762 : :
763 : 4 : rc = nvmf_bdev_ctrlr_compare_cmd(&bdev, &desc, &ch, &req);
764 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
765 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
766 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
767 : :
768 : : /* bdev not support flush */
769 : 4 : MOCK_SET(spdk_bdev_io_type_supported, false);
770 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
771 : :
772 : 4 : rc = nvmf_bdev_ctrlr_flush_cmd(&bdev, &desc, &ch, &req);
773 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
774 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
775 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
776 : :
777 : : /* Flush error */
778 : 4 : MOCK_SET(spdk_bdev_io_type_supported, true);
779 : 4 : MOCK_SET(spdk_bdev_flush_blocks, -1);
780 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
781 : :
782 : 4 : rc = nvmf_bdev_ctrlr_flush_cmd(&bdev, &desc, &ch, &req);
783 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
784 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
785 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
786 : :
787 : : /* Flush blocks status asynchronous */
788 : 4 : MOCK_SET(spdk_bdev_flush_blocks, 0);
789 : :
790 : 4 : rc = nvmf_bdev_ctrlr_flush_cmd(&bdev, &desc, &ch, &req);
791 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
792 [ - + - + ]: 4 : MOCK_CLEAR(spdk_bdev_io_type_supported);
793 [ - + - + ]: 4 : MOCK_CLEAR(spdk_bdev_flush_blocks);
794 : :
795 : : /* Write zeroes blocks status asynchronous */
796 : 4 : struct spdk_nvmf_subsystem subsystem = { };
797 : 4 : struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem };
798 : 4 : qpair.ctrlr = &ctrlr;
799 : :
800 : 4 : rc = nvmf_bdev_ctrlr_write_zeroes_cmd(&bdev, &desc, &ch, &req);
801 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
802 : :
803 : 4 : cmd.nvme_cmd.cdw12 = 3;
804 : 4 : subsystem.max_write_zeroes_size_kib = 1;
805 : 4 : rc = nvmf_bdev_ctrlr_write_zeroes_cmd(&bdev, &desc, &ch, &req);
806 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
807 : :
808 : : /* SLBA out of range */
809 : 4 : subsystem.max_write_zeroes_size_kib = 0;
810 : 4 : cmd.nvme_cmd.cdw12 = 2;
811 : 4 : cmd.nvme_cmd.cdw10 = 3;
812 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
813 : :
814 : 4 : rc = nvmf_bdev_ctrlr_write_zeroes_cmd(&bdev, &desc, &ch, &req);
815 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
816 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
817 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_LBA_OUT_OF_RANGE);
818 : :
819 : : /* Write block error */
820 : 4 : MOCK_SET(spdk_bdev_write_zeroes_blocks, -1);
821 : 4 : cmd.nvme_cmd.cdw10 = 0;
822 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
823 : :
824 : 4 : rc = nvmf_bdev_ctrlr_write_zeroes_cmd(&bdev, &desc, &ch, &req);
825 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
826 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
827 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
828 : :
829 : : /* Copy blocks status asynchronous */
830 : 4 : MOCK_SET(spdk_bdev_io_type_supported, true);
831 : 4 : cmd.nvme_cmd.cdw10 = 1024;
832 : 4 : cmd.nvme_cmd.cdw11 = 0;
833 : 4 : cmd.nvme_cmd.cdw12 = 0;
834 : 4 : cmd.nvme_cmd.cdw12_bits.copy.nr = 0;
835 : 4 : range.slba = 512;
836 : 4 : range.nlb = 511;
837 : 4 : req.length = 32;
838 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &range, req.length);
839 : 4 : rc = nvmf_bdev_ctrlr_copy_cmd(&bdev, NULL, &ch, &req);
840 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
841 : :
842 : : /* Copy command not supported */
843 : 4 : MOCK_SET(spdk_bdev_io_type_supported, false);
844 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
845 : :
846 : 4 : rc = nvmf_bdev_ctrlr_copy_cmd(&bdev, &desc, &ch, &req);
847 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
848 : :
849 : 4 : MOCK_SET(spdk_bdev_io_type_supported, true);
850 : :
851 : : /* Unsupported number of source ranges */
852 : 4 : cmd.nvme_cmd.cdw12_bits.copy.nr = 1;
853 : 4 : req.length = 64;
854 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
855 : :
856 : 4 : rc = nvmf_bdev_ctrlr_copy_cmd(&bdev, &desc, &ch, &req);
857 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
858 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
859 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_CMD_SIZE_LIMIT_SIZE_EXCEEDED);
860 : :
861 : 4 : cmd.nvme_cmd.cdw12_bits.copy.nr = 0;
862 : 4 : req.length = 32;
863 : :
864 : : /* Unsupported source range descriptor format */
865 : 4 : cmd.nvme_cmd.cdw12_bits.copy.df = 1;
866 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
867 : :
868 : 4 : rc = nvmf_bdev_ctrlr_copy_cmd(&bdev, &desc, &ch, &req);
869 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
870 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
871 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
872 : :
873 : 4 : cmd.nvme_cmd.cdw12_bits.copy.df = 0;
874 : :
875 : : /* Bdev copy command failed */
876 : 4 : MOCK_SET(spdk_bdev_copy_blocks, -1);
877 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
878 : :
879 : 4 : rc = nvmf_bdev_ctrlr_copy_cmd(&bdev, &desc, &ch, &req);
880 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
881 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
882 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
883 : :
884 [ - + - + ]: 4 : MOCK_CLEAR(spdk_bdev_copy_blocks);
885 [ - + - + ]: 4 : MOCK_CLEAR(spdk_bdev_io_type_supported);
886 : 4 : }
887 : :
888 : : static void
889 : 4 : test_nvmf_bdev_ctrlr_read_write_cmd(void)
890 : : {
891 : 4 : struct spdk_bdev bdev = {};
892 : 4 : struct spdk_bdev_desc desc = { .bdev = &bdev, };
893 : 4 : struct spdk_nvmf_request req = {};
894 : 4 : union nvmf_c2h_msg rsp = {};
895 : 4 : union nvmf_h2c_msg cmd = {};
896 : : int rc;
897 : :
898 : 4 : req.cmd = &cmd;
899 : 4 : req.rsp = &rsp;
900 : :
901 : : /* Read two blocks, block size 4096 */
902 : 4 : cmd.nvme_cmd.cdw12 = 1;
903 : 4 : bdev.blockcnt = 100;
904 : 4 : bdev.blocklen = 4096;
905 : 4 : req.length = 8192;
906 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
907 : :
908 : 4 : rc = nvmf_bdev_ctrlr_read_cmd(&bdev, &desc, NULL, &req);
909 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
910 : :
911 : : /* Write two blocks, block size 4096 */
912 : 4 : cmd.nvme_cmd.cdw12 = 1;
913 : 4 : bdev.blockcnt = 100;
914 : 4 : bdev.blocklen = 4096;
915 : 4 : req.length = 8192;
916 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
917 : :
918 : 4 : rc = nvmf_bdev_ctrlr_write_cmd(&bdev, &desc, NULL, &req);
919 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
920 : 4 : }
921 : :
922 : : static void
923 : 4 : test_nvmf_bdev_ctrlr_nvme_passthru(void)
924 : : {
925 : : int rc;
926 : 4 : struct spdk_bdev bdev = {};
927 : 4 : struct spdk_bdev_desc *desc = NULL;
928 : 4 : struct spdk_io_channel ch = {};
929 : 4 : struct spdk_nvmf_qpair qpair = {};
930 : 4 : struct spdk_nvmf_poll_group group = {};
931 : :
932 : 4 : struct spdk_nvmf_request req = {};
933 : 4 : union nvmf_c2h_msg rsp = {};
934 : 4 : struct spdk_nvme_cmd cmd = {};
935 : 3 : struct spdk_bdev_io bdev_io;
936 : :
937 : 4 : bdev.blocklen = 512;
938 : 4 : bdev.blockcnt = 10;
939 : :
940 : 4 : qpair.group = &group;
941 : :
942 : 4 : req.qpair = &qpair;
943 : 4 : req.cmd = (union nvmf_h2c_msg *)&cmd;
944 : 4 : req.rsp = &rsp;
945 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, NULL, 0);
946 : :
947 : 4 : cmd.nsid = 1;
948 : 4 : cmd.opc = 0xFF;
949 : :
950 : 4 : cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */
951 : 4 : cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */
952 : :
953 : : /* NVME_IO success */
954 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
955 : 4 : rc = nvmf_bdev_ctrlr_nvme_passthru_io(&bdev, desc, &ch, &req);
956 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
957 : 4 : nvmf_bdev_ctrlr_complete_cmd(&bdev_io, true, &req);
958 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
959 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
960 : :
961 : : /* NVME_IO fail */
962 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
963 : 4 : rc = nvmf_bdev_ctrlr_nvme_passthru_io(&bdev, desc, &ch, &req);
964 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
965 : 4 : g_bdev_nvme_status_sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
966 : 4 : nvmf_bdev_ctrlr_complete_cmd(&bdev_io, false, &req);
967 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
968 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
969 : 4 : reset_bdev_nvme_status();
970 : :
971 : : /* NVME_IO not supported */
972 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
973 : 4 : MOCK_SET(spdk_bdev_nvme_iov_passthru_md, -ENOTSUP);
974 : 4 : rc = nvmf_bdev_ctrlr_nvme_passthru_io(&bdev, desc, &ch, &req);
975 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
976 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
977 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE);
978 : 4 : CU_ASSERT(rsp.nvme_cpl.status.dnr == 1);
979 : :
980 : : /* NVME_IO no channel - queue IO */
981 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
982 : 4 : MOCK_SET(spdk_bdev_nvme_iov_passthru_md, -ENOMEM);
983 : 4 : rc = nvmf_bdev_ctrlr_nvme_passthru_io(&bdev, desc, &ch, &req);
984 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
985 : 4 : CU_ASSERT(group.stat.pending_bdev_io == 1);
986 : :
987 : 4 : MOCK_SET(spdk_bdev_nvme_iov_passthru_md, 0);
988 : :
989 : : /* NVME_ADMIN success */
990 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
991 : 4 : rc = spdk_nvmf_bdev_ctrlr_nvme_passthru_admin(&bdev, desc, &ch, &req, NULL);
992 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
993 : 4 : nvmf_bdev_ctrlr_complete_admin_cmd(&bdev_io, true, &req);
994 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
995 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
996 : :
997 : : /* NVME_ADMIN fail */
998 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
999 : 4 : rc = spdk_nvmf_bdev_ctrlr_nvme_passthru_admin(&bdev, desc, &ch, &req, NULL);
1000 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
1001 : 4 : g_bdev_nvme_status_sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
1002 : 4 : nvmf_bdev_ctrlr_complete_admin_cmd(&bdev_io, true, &req);
1003 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1004 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INTERNAL_DEVICE_ERROR);
1005 : 4 : reset_bdev_nvme_status();
1006 : :
1007 : : /* NVME_ADMIN not supported */
1008 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1009 : 4 : MOCK_SET(spdk_bdev_nvme_admin_passthru, -ENOTSUP);
1010 : 4 : rc = spdk_nvmf_bdev_ctrlr_nvme_passthru_admin(&bdev, desc, &ch, &req, NULL);
1011 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1012 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1013 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE);
1014 : 4 : CU_ASSERT(rsp.nvme_cpl.status.dnr == 1);
1015 : :
1016 : : /* NVME_ADMIN no channel - queue IO */
1017 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1018 : 4 : MOCK_SET(spdk_bdev_nvme_admin_passthru, -ENOMEM);
1019 : 4 : rc = spdk_nvmf_bdev_ctrlr_nvme_passthru_admin(&bdev, desc, &ch, &req, NULL);
1020 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
1021 : 4 : CU_ASSERT(group.stat.pending_bdev_io == 2);
1022 : :
1023 : 4 : MOCK_SET(spdk_bdev_nvme_admin_passthru, 0);
1024 : 4 : }
1025 : :
1026 : : int
1027 : 4 : main(int argc, char **argv)
1028 : : {
1029 : 4 : CU_pSuite suite = NULL;
1030 : : unsigned int num_failures;
1031 : :
1032 : 4 : CU_initialize_registry();
1033 : :
1034 : 4 : suite = CU_add_suite("nvmf", NULL, NULL);
1035 : :
1036 : 4 : CU_ADD_TEST(suite, test_get_rw_params);
1037 : 4 : CU_ADD_TEST(suite, test_get_rw_ext_params);
1038 : 4 : CU_ADD_TEST(suite, test_lba_in_range);
1039 : 4 : CU_ADD_TEST(suite, test_get_dif_ctx);
1040 : 4 : CU_ADD_TEST(suite, test_nvmf_bdev_ctrlr_identify_ns);
1041 : 4 : CU_ADD_TEST(suite, test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd);
1042 : 4 : CU_ADD_TEST(suite, test_nvmf_bdev_ctrlr_zcopy_start);
1043 : 4 : CU_ADD_TEST(suite, test_nvmf_bdev_ctrlr_cmd);
1044 : 4 : CU_ADD_TEST(suite, test_nvmf_bdev_ctrlr_read_write_cmd);
1045 : 4 : CU_ADD_TEST(suite, test_nvmf_bdev_ctrlr_nvme_passthru);
1046 : :
1047 : 4 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1048 : 4 : CU_cleanup_registry();
1049 : 4 : return num_failures;
1050 : : }
|