Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2016 Intel Corporation. All rights reserved.
3 : : * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved.
4 : : * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/bdev_zone.h"
8 : : #include "spdk/nvme_spec.h"
9 : : #include "spdk/stdinc.h"
10 : :
11 : : #include "spdk_internal/cunit.h"
12 : : #include "spdk_internal/mock.h"
13 : : #include "thread/thread_internal.h"
14 : :
15 : : #include "common/lib/ut_multithread.c"
16 : : #include "nvmf/ctrlr.c"
17 : :
18 : 4 : SPDK_LOG_REGISTER_COMPONENT(nvmf)
19 : :
20 : : struct spdk_bdev {
21 : : int ut_mock;
22 : : uint64_t blockcnt;
23 : : uint32_t blocklen;
24 : : bool zoned;
25 : : uint32_t zone_size;
26 : : uint32_t max_open_zones;
27 : : uint32_t max_active_zones;
28 : : enum spdk_dif_type dif_type;
29 : : };
30 : :
31 : : #define MAX_OPEN_ZONES 12
32 : : #define MAX_ACTIVE_ZONES 34
33 : : #define ZONE_SIZE 56
34 : :
35 : : const char subsystem_default_sn[SPDK_NVME_CTRLR_SN_LEN + 1] = "subsys_default_sn";
36 : : const char subsystem_default_mn[SPDK_NVME_CTRLR_MN_LEN + 1] = "subsys_default_mn";
37 : :
38 : : static struct spdk_bdev_io *zcopy_start_bdev_io_read = (struct spdk_bdev_io *) 0x1122334455667788UL;
39 : : static struct spdk_bdev_io *zcopy_start_bdev_io_write = (struct spdk_bdev_io *)
40 : : 0x8877665544332211UL;
41 : : static struct spdk_bdev_io *zcopy_start_bdev_io_fail = (struct spdk_bdev_io *) 0xFFFFFFFFFFFFFFFFUL;
42 : :
43 [ - + - + ]: 252 : DEFINE_STUB(spdk_nvmf_tgt_find_subsystem,
44 : : struct spdk_nvmf_subsystem *,
45 : : (struct spdk_nvmf_tgt *tgt, const char *subnqn),
46 : : NULL);
47 : :
48 [ # # # # ]: 0 : DEFINE_STUB(spdk_nvmf_poll_group_create,
49 : : struct spdk_nvmf_poll_group *,
50 : : (struct spdk_nvmf_tgt *tgt),
51 : : NULL);
52 : :
53 [ - + # # ]: 12 : DEFINE_STUB(spdk_nvmf_subsystem_get_sn,
54 : : const char *,
55 : : (const struct spdk_nvmf_subsystem *subsystem),
56 : : subsystem_default_sn);
57 : :
58 [ - + # # ]: 12 : DEFINE_STUB(spdk_nvmf_subsystem_get_mn,
59 : : const char *,
60 : : (const struct spdk_nvmf_subsystem *subsystem),
61 : : subsystem_default_mn);
62 : :
63 [ - + - + ]: 84 : DEFINE_STUB(spdk_nvmf_subsystem_host_allowed,
64 : : bool,
65 : : (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn),
66 : : true);
67 : :
68 [ - + - + ]: 20 : DEFINE_STUB(nvmf_subsystem_add_ctrlr,
69 : : int,
70 : : (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr),
71 : : 0);
72 : :
73 [ - + - + ]: 44 : DEFINE_STUB(nvmf_subsystem_get_ctrlr,
74 : : struct spdk_nvmf_ctrlr *,
75 : : (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid),
76 : : NULL);
77 [ # # # # ]: 0 : DEFINE_STUB(nvmf_subsystem_zone_append_supported, bool,
78 : : (struct spdk_nvmf_subsystem *subsystem), false);
79 [ - + - + ]: 12 : DEFINE_STUB(nvmf_ctrlr_dsm_supported,
80 : : bool,
81 : : (struct spdk_nvmf_ctrlr *ctrlr),
82 : : false);
83 : :
84 [ - + - + ]: 12 : DEFINE_STUB(nvmf_ctrlr_write_zeroes_supported,
85 : : bool,
86 : : (struct spdk_nvmf_ctrlr *ctrlr),
87 : : false);
88 : :
89 [ # # # # ]: 0 : DEFINE_STUB(nvmf_ctrlr_copy_supported,
90 : : bool,
91 : : (struct spdk_nvmf_ctrlr *ctrlr),
92 : : false);
93 : :
94 : 0 : DEFINE_STUB_V(nvmf_get_discovery_log_page,
95 : : (struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov,
96 : : uint32_t iovcnt, uint64_t offset, uint32_t length, struct spdk_nvme_transport_id *cmd_src_trid));
97 : :
98 [ - + - + ]: 92 : DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid,
99 : : int,
100 : : (struct spdk_nvmf_qpair *qpair, struct spdk_nvme_transport_id *trid),
101 : : 0);
102 : :
103 [ - + - + ]: 80 : DEFINE_STUB(spdk_nvmf_subsystem_listener_allowed,
104 : : bool,
105 : : (struct spdk_nvmf_subsystem *subsystem, const struct spdk_nvme_transport_id *trid),
106 : : true);
107 : :
108 [ - + - + ]: 12 : DEFINE_STUB(nvmf_subsystem_find_listener,
109 : : struct spdk_nvmf_subsystem_listener *,
110 : : (struct spdk_nvmf_subsystem *subsystem,
111 : : const struct spdk_nvme_transport_id *trid),
112 : : (void *)0x1);
113 : :
114 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_read_cmd,
115 : : int,
116 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
117 : : struct spdk_nvmf_request *req),
118 : : 0);
119 : :
120 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_write_cmd,
121 : : int,
122 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
123 : : struct spdk_nvmf_request *req),
124 : : 0);
125 : :
126 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_compare_cmd,
127 : : int,
128 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
129 : : struct spdk_nvmf_request *req),
130 : : 0);
131 : :
132 [ - + - + ]: 4 : DEFINE_STUB(nvmf_bdev_ctrlr_compare_and_write_cmd,
133 : : int,
134 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
135 : : struct spdk_nvmf_request *cmp_req, struct spdk_nvmf_request *write_req),
136 : : 0);
137 : :
138 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_write_zeroes_cmd,
139 : : int,
140 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
141 : : struct spdk_nvmf_request *req),
142 : : 0);
143 : :
144 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_flush_cmd,
145 : : int,
146 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
147 : : struct spdk_nvmf_request *req),
148 : : 0);
149 : :
150 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_dsm_cmd,
151 : : int,
152 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
153 : : struct spdk_nvmf_request *req),
154 : : 0);
155 : :
156 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_copy_cmd,
157 : : int,
158 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
159 : : struct spdk_nvmf_request *req),
160 : : 0);
161 : :
162 [ # # # # ]: 0 : DEFINE_STUB(nvmf_bdev_ctrlr_nvme_passthru_io,
163 : : int,
164 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
165 : : struct spdk_nvmf_request *req),
166 : : 0);
167 : :
168 [ - + - + ]: 160 : DEFINE_STUB(nvmf_transport_req_complete,
169 : : int,
170 : : (struct spdk_nvmf_request *req),
171 : : 0);
172 : :
173 : 0 : DEFINE_STUB_V(nvmf_ns_reservation_request, (void *ctx));
174 : :
175 [ - + - + ]: 4 : DEFINE_STUB(nvmf_bdev_ctrlr_get_dif_ctx, bool,
176 : : (struct spdk_bdev *bdev, struct spdk_nvme_cmd *cmd,
177 : : struct spdk_dif_ctx *dif_ctx),
178 : : true);
179 : :
180 : 0 : DEFINE_STUB_V(nvmf_transport_qpair_abort_request,
181 : : (struct spdk_nvmf_qpair *qpair, struct spdk_nvmf_request *req));
182 : :
183 : 0 : DEFINE_STUB_V(spdk_nvme_print_command, (uint16_t qid, struct spdk_nvme_cmd *cmd));
184 : 0 : DEFINE_STUB_V(spdk_nvme_print_completion, (uint16_t qid, struct spdk_nvme_cpl *cpl));
185 : :
186 : 4 : DEFINE_STUB_V(nvmf_subsystem_remove_ctrlr, (struct spdk_nvmf_subsystem *subsystem,
187 : : struct spdk_nvmf_ctrlr *ctrlr));
188 : :
189 [ # # # # ]: 0 : DEFINE_STUB(spdk_nvmf_bdev_ctrlr_abort_cmd,
190 : : int,
191 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
192 : : struct spdk_nvmf_request *req, struct spdk_nvmf_request *req_to_abort),
193 : : 0);
194 : :
195 [ # # # # ]: 0 : DEFINE_STUB(nvmf_transport_req_free,
196 : : int,
197 : : (struct spdk_nvmf_request *req),
198 : : 0);
199 : :
200 [ # # # # ]: 0 : DEFINE_STUB(spdk_nvmf_bdev_ctrlr_nvme_passthru_admin,
201 : : int,
202 : : (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
203 : : struct spdk_nvmf_request *req, spdk_nvmf_nvme_passthru_cmd_cb cb_fn),
204 : : 0);
205 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_reset, int, (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
206 : : spdk_bdev_io_completion_cb cb, void *cb_arg), 0);
207 : 0 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io));
208 : :
209 [ - + - + ]: 4 : DEFINE_STUB(spdk_bdev_get_max_active_zones, uint32_t, (const struct spdk_bdev *bdev),
210 : : MAX_ACTIVE_ZONES);
211 [ - + - + ]: 4 : DEFINE_STUB(spdk_bdev_get_max_open_zones, uint32_t, (const struct spdk_bdev *bdev), MAX_OPEN_ZONES);
212 [ - + - + ]: 4 : DEFINE_STUB(spdk_bdev_get_zone_size, uint64_t, (const struct spdk_bdev *bdev), ZONE_SIZE);
213 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_is_zoned, bool, (const struct spdk_bdev *bdev), false);
214 : :
215 [ - + - + ]: 8 : DEFINE_STUB(spdk_nvme_ns_get_format_index, uint32_t,
216 : : (const struct spdk_nvme_ns_data *nsdata), 0);
217 : :
218 [ - + - + ]: 212 : DEFINE_STUB(spdk_nvmf_subsystem_is_discovery, bool, (struct spdk_nvmf_subsystem *subsystem), false);
219 [ - + - + ]: 28 : DEFINE_STUB(nvmf_subsystem_host_auth_required, bool, (struct spdk_nvmf_subsystem *s, const char *n),
220 : : false);
221 [ # # # # ]: 0 : DEFINE_STUB(nvmf_qpair_auth_init, int, (struct spdk_nvmf_qpair *q), 0);
222 [ # # # # ]: 0 : DEFINE_STUB(nvmf_auth_request_exec, int, (struct spdk_nvmf_request *r),
223 : : SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
224 : :
225 [ - + - + ]: 32 : DEFINE_STUB(spdk_nvmf_subsystem_get_nqn, const char *,
226 : : (const struct spdk_nvmf_subsystem *subsystem), NULL);
227 : :
228 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_io_type_supported, bool,
229 : : (struct spdk_bdev *bdev, enum spdk_bdev_io_type io_type), false);
230 : :
231 : : void
232 : 28 : nvmf_qpair_set_state(struct spdk_nvmf_qpair *qpair, enum spdk_nvmf_qpair_state state)
233 : : {
234 : 28 : qpair->state = state;
235 : 28 : }
236 : :
237 : : int
238 : 0 : spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair)
239 : : {
240 : 0 : return 0;
241 : : }
242 : :
243 : : void
244 : 8 : nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata,
245 : : bool dif_insert_or_strip)
246 : : {
247 : : uint64_t num_blocks;
248 : :
249 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(ns->bdev != NULL);
250 : 8 : num_blocks = ns->bdev->blockcnt;
251 : 8 : nsdata->nsze = num_blocks;
252 : 8 : nsdata->ncap = num_blocks;
253 : 8 : nsdata->nuse = num_blocks;
254 : 8 : nsdata->nlbaf = 0;
255 : 8 : nsdata->flbas.format = 0;
256 : 8 : nsdata->flbas.msb_format = 0;
257 : 8 : nsdata->lbaf[0].lbads = spdk_u32log2(512);
258 : 8 : }
259 : :
260 : : void
261 : 4 : nvmf_bdev_ctrlr_identify_iocs_nvm(struct spdk_nvmf_ns *ns,
262 : : struct spdk_nvme_nvm_ns_data *nsdata_nvm)
263 : : {
264 [ - + ]: 4 : if (ns->bdev->dif_type == SPDK_DIF_DISABLE) {
265 : 0 : return;
266 : : }
267 : :
268 : 4 : nsdata_nvm->lbstm = 0;
269 : 4 : nsdata_nvm->pic._16bpists = 0;
270 : 4 : nsdata_nvm->pic._16bpistm = 1;
271 : 4 : nsdata_nvm->pic.stcrs = 0;
272 : 4 : nsdata_nvm->elbaf[0].sts = 16;
273 : 4 : nsdata_nvm->elbaf[0].pif = SPDK_DIF_PI_FORMAT_32;
274 : 1 : }
275 : :
276 : : struct spdk_nvmf_ns *
277 : 116 : spdk_nvmf_subsystem_get_first_ns(struct spdk_nvmf_subsystem *subsystem)
278 : : {
279 [ + + ]: 116 : SPDK_CU_ASSERT_FATAL(subsystem->ns != NULL);
280 : 116 : return subsystem->ns[0];
281 : : }
282 : :
283 : : struct spdk_nvmf_ns *
284 : 296 : spdk_nvmf_subsystem_get_next_ns(struct spdk_nvmf_subsystem *subsystem,
285 : : struct spdk_nvmf_ns *prev_ns)
286 : : {
287 : : uint32_t nsid;
288 : :
289 [ + + ]: 296 : SPDK_CU_ASSERT_FATAL(subsystem->ns != NULL);
290 : 296 : nsid = prev_ns->nsid;
291 : :
292 [ + + ]: 296 : if (nsid >= subsystem->max_nsid) {
293 : 76 : return NULL;
294 : : }
295 [ + - ]: 236 : for (nsid = nsid + 1; nsid <= subsystem->max_nsid; nsid++) {
296 [ + + ]: 236 : if (subsystem->ns[nsid - 1]) {
297 : 220 : return subsystem->ns[nsid - 1];
298 : : }
299 : 4 : }
300 : 0 : return NULL;
301 : 74 : }
302 : :
303 : : bool
304 : 0 : nvmf_bdev_zcopy_enabled(struct spdk_bdev *bdev)
305 : : {
306 : 0 : return true;
307 : : }
308 : :
309 : : int
310 : 16 : nvmf_bdev_ctrlr_zcopy_start(struct spdk_bdev *bdev,
311 : : struct spdk_bdev_desc *desc,
312 : : struct spdk_io_channel *ch,
313 : : struct spdk_nvmf_request *req)
314 : : {
315 : 16 : struct spdk_nvme_cpl *rsp = &req->rsp->nvme_cpl;
316 : : uint64_t start_lba;
317 : : uint64_t num_blocks;
318 : :
319 : 16 : start_lba = from_le64(&req->cmd->nvme_cmd.cdw10);
320 : 16 : num_blocks = (from_le32(&req->cmd->nvme_cmd.cdw12) & 0xFFFFu) + 1;
321 : :
322 [ + + ]: 16 : if ((start_lba + num_blocks) > bdev->blockcnt) {
323 : 4 : rsp->status.sct = SPDK_NVME_SCT_GENERIC;
324 : 4 : rsp->status.sc = SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID;
325 : 4 : return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
326 : : }
327 : :
328 [ + + ]: 12 : if (req->cmd->nvme_cmd.opc == SPDK_NVME_OPC_WRITE) {
329 : 4 : req->zcopy_bdev_io = zcopy_start_bdev_io_write;
330 [ + - ]: 9 : } else if (req->cmd->nvme_cmd.opc == SPDK_NVME_OPC_READ) {
331 : 8 : req->zcopy_bdev_io = zcopy_start_bdev_io_read;
332 : 2 : } else {
333 : 0 : req->zcopy_bdev_io = zcopy_start_bdev_io_fail;
334 : : }
335 : :
336 : :
337 : 12 : return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
338 : 4 : }
339 : :
340 : : void
341 : 8 : nvmf_bdev_ctrlr_zcopy_end(struct spdk_nvmf_request *req, bool commit)
342 : : {
343 : 8 : req->zcopy_bdev_io = NULL;
344 : 8 : spdk_nvmf_request_complete(req);
345 : 8 : }
346 : :
347 : : bool
348 : 4 : nvmf_ns_is_ptpl_capable(const struct spdk_nvmf_ns *ns)
349 : : {
350 : 4 : return ns->ptpl_file != NULL;
351 : : }
352 : :
353 : : static void
354 : 4 : test_get_log_page(void)
355 : : {
356 : 4 : struct spdk_nvmf_subsystem subsystem = {};
357 : 4 : struct spdk_nvmf_request req = {};
358 : 4 : struct spdk_nvmf_qpair qpair = {};
359 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
360 : 4 : union nvmf_h2c_msg cmd = {};
361 : 4 : union nvmf_c2h_msg rsp = {};
362 : 3 : char data[4096];
363 : :
364 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
365 : :
366 : 4 : ctrlr.subsys = &subsystem;
367 : :
368 : 4 : qpair.ctrlr = &ctrlr;
369 : :
370 : 4 : req.qpair = &qpair;
371 : 4 : req.cmd = &cmd;
372 : 4 : req.rsp = &rsp;
373 : 4 : req.length = sizeof(data);
374 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &data, req.length);
375 : :
376 : : /* Get Log Page - all valid */
377 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
378 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
379 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
380 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR;
381 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = spdk_nvme_bytes_to_numd(req.length);
382 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
383 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
384 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
385 : :
386 : : /* Get Log Page with invalid log ID */
387 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
388 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
389 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
390 : 4 : cmd.nvme_cmd.cdw10 = 0;
391 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
392 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
393 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
394 : :
395 : : /* Get Log Page with invalid offset (not dword aligned) */
396 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
397 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
398 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
399 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR;
400 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = spdk_nvme_bytes_to_numd(req.length);
401 : 4 : cmd.nvme_cmd.cdw12 = 2;
402 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
403 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
404 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
405 : :
406 : : /* Get Log Page without data buffer */
407 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
408 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
409 : 4 : req.iovcnt = 0;
410 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
411 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR;
412 : 4 : cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = spdk_nvme_bytes_to_numd(req.length);
413 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
414 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
415 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
416 : 4 : }
417 : :
418 : : static void
419 : 4 : test_process_fabrics_cmd(void)
420 : : {
421 : 4 : struct spdk_nvmf_request req = {};
422 : : bool ret;
423 : 4 : struct spdk_nvmf_qpair req_qpair = {};
424 : 4 : union nvmf_h2c_msg req_cmd = {};
425 : 4 : union nvmf_c2h_msg req_rsp = {};
426 : :
427 : 4 : TAILQ_INIT(&req_qpair.outstanding);
428 : 4 : req_qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
429 : 4 : req.qpair = &req_qpair;
430 : 4 : req.cmd = &req_cmd;
431 : 4 : req.rsp = &req_rsp;
432 : 4 : req.qpair->ctrlr = NULL;
433 : :
434 : : /* No ctrlr and invalid command check */
435 : 4 : req.cmd->nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET;
436 : 4 : ret = nvmf_check_qpair_active(&req);
437 : 4 : CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
438 : 4 : CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR);
439 : 4 : CU_ASSERT(ret == false);
440 : 4 : }
441 : :
442 : : static bool
443 : 56 : nvme_status_success(const struct spdk_nvme_status *status)
444 : : {
445 [ + - + + ]: 56 : return status->sct == SPDK_NVME_SCT_GENERIC && status->sc == SPDK_NVME_SC_SUCCESS;
446 : : }
447 : :
448 : : static void
449 : 4 : test_connect(void)
450 : : {
451 : 3 : struct spdk_nvmf_fabric_connect_data connect_data;
452 : 3 : struct spdk_nvmf_poll_group group;
453 : : struct spdk_nvmf_subsystem_poll_group *sgroups;
454 : 3 : struct spdk_nvmf_transport transport;
455 : 4 : struct spdk_nvmf_transport_ops tops = {};
456 : 3 : struct spdk_nvmf_subsystem subsystem;
457 : 4 : struct spdk_nvmf_ns *ns_arr[1] = { NULL };
458 : 3 : struct spdk_nvmf_request req;
459 : 3 : struct spdk_nvmf_qpair admin_qpair;
460 : 3 : struct spdk_nvmf_qpair qpair;
461 : 3 : struct spdk_nvmf_ctrlr ctrlr;
462 : 3 : struct spdk_nvmf_tgt tgt;
463 : 3 : union nvmf_h2c_msg cmd;
464 : 3 : union nvmf_c2h_msg rsp;
465 : 4 : const uint8_t hostid[16] = {
466 : : 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
467 : : 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
468 : : };
469 : 4 : const char subnqn[] = "nqn.2016-06.io.spdk:subsystem1";
470 : 4 : const char hostnqn[] = "nqn.2016-06.io.spdk:host1";
471 : : int rc;
472 : :
473 [ - + ]: 4 : memset(&group, 0, sizeof(group));
474 : 4 : group.thread = spdk_get_thread();
475 : :
476 [ - + ]: 4 : memset(&ctrlr, 0, sizeof(ctrlr));
477 : 4 : ctrlr.subsys = &subsystem;
478 : 4 : ctrlr.qpair_mask = spdk_bit_array_create(3);
479 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlr.qpair_mask != NULL);
480 : 4 : ctrlr.vcprop.cc.bits.en = 1;
481 : 4 : ctrlr.vcprop.cc.bits.iosqes = 6;
482 : 4 : ctrlr.vcprop.cc.bits.iocqes = 4;
483 : :
484 [ - + ]: 4 : memset(&admin_qpair, 0, sizeof(admin_qpair));
485 : 4 : admin_qpair.group = &group;
486 : 4 : admin_qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
487 : :
488 [ - + ]: 4 : memset(&tgt, 0, sizeof(tgt));
489 [ - + ]: 4 : memset(&transport, 0, sizeof(transport));
490 : 4 : transport.ops = &tops;
491 : 4 : transport.opts.max_aq_depth = 32;
492 : 4 : transport.opts.max_queue_depth = 64;
493 : 4 : transport.opts.max_qpairs_per_ctrlr = 3;
494 : 4 : transport.tgt = &tgt;
495 : :
496 [ - + ]: 4 : memset(&qpair, 0, sizeof(qpair));
497 : 4 : qpair.transport = &transport;
498 : 4 : qpair.group = &group;
499 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
500 : 4 : TAILQ_INIT(&qpair.outstanding);
501 : :
502 [ - + ]: 4 : memset(&connect_data, 0, sizeof(connect_data));
503 : 4 : memcpy(connect_data.hostid, hostid, sizeof(hostid));
504 : 4 : connect_data.cntlid = 0xFFFF;
505 [ - + ]: 4 : snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn);
506 [ - + ]: 4 : snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn);
507 : :
508 [ - + ]: 4 : memset(&subsystem, 0, sizeof(subsystem));
509 : 4 : subsystem.thread = spdk_get_thread();
510 : 4 : subsystem.id = 1;
511 : 4 : TAILQ_INIT(&subsystem.ctrlrs);
512 : 4 : subsystem.tgt = &tgt;
513 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
514 : 4 : subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
515 [ - + ]: 4 : snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn);
516 : 4 : subsystem.ns = ns_arr;
517 : 4 : subsystem.max_nsid = 1;
518 : :
519 : 4 : sgroups = calloc(subsystem.id + 1, sizeof(struct spdk_nvmf_subsystem_poll_group));
520 : 4 : group.sgroups = sgroups;
521 : :
522 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
523 : 4 : cmd.connect_cmd.opcode = SPDK_NVME_OPC_FABRIC;
524 : 4 : cmd.connect_cmd.cid = 1;
525 : 4 : cmd.connect_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT;
526 : 4 : cmd.connect_cmd.recfmt = 0;
527 : 4 : cmd.connect_cmd.qid = 0;
528 : 4 : cmd.connect_cmd.sqsize = 31;
529 : 4 : cmd.connect_cmd.cattr = 0;
530 : 4 : cmd.connect_cmd.kato = 120000;
531 : :
532 [ - + ]: 4 : memset(&req, 0, sizeof(req));
533 : 4 : req.qpair = &qpair;
534 : 4 : req.xfer = SPDK_NVME_DATA_HOST_TO_CONTROLLER;
535 : 4 : req.length = sizeof(connect_data);
536 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &connect_data, req.length);
537 : 4 : req.cmd = &cmd;
538 : 4 : req.rsp = &rsp;
539 : :
540 : 4 : MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem);
541 : 4 : MOCK_SET(spdk_nvmf_poll_group_create, &group);
542 : :
543 : : /* Valid admin connect command */
544 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
545 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
546 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
547 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
548 : 4 : poll_threads();
549 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
550 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
551 : 4 : CU_ASSERT(qpair.ctrlr != NULL);
552 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
553 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
554 : 4 : nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr);
555 : 4 : spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
556 : 4 : free(qpair.ctrlr->visible_ns);
557 : 4 : free(qpair.ctrlr);
558 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
559 : 4 : qpair.ctrlr = NULL;
560 : :
561 : : /* Valid admin connect command with kato = 0 */
562 : 4 : cmd.connect_cmd.kato = 0;
563 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
564 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
565 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
566 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
567 : 4 : poll_threads();
568 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
569 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
570 [ + + + - ]: 4 : CU_ASSERT(qpair.ctrlr != NULL && qpair.ctrlr->keep_alive_poller == NULL);
571 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
572 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
573 : 4 : spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
574 : 4 : free(qpair.ctrlr->visible_ns);
575 : 4 : free(qpair.ctrlr);
576 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
577 : 4 : qpair.ctrlr = NULL;
578 : 4 : cmd.connect_cmd.kato = 120000;
579 : :
580 : : /* Invalid data length */
581 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
582 : 4 : req.length = sizeof(connect_data) - 1;
583 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
584 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
585 : 4 : poll_threads();
586 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
587 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
588 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
589 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
590 : 4 : req.length = sizeof(connect_data);
591 : :
592 : : /* Invalid recfmt */
593 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
594 : 4 : cmd.connect_cmd.recfmt = 1234;
595 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
596 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
597 : 4 : poll_threads();
598 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
599 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
600 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT);
601 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
602 : 4 : cmd.connect_cmd.recfmt = 0;
603 : :
604 : : /* Subsystem not found */
605 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
606 : 4 : MOCK_SET(spdk_nvmf_tgt_find_subsystem, NULL);
607 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
608 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
609 : 4 : poll_threads();
610 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
611 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
612 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
613 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1);
614 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256);
615 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
616 : 4 : MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem);
617 : :
618 : : /* Unterminated hostnqn */
619 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
620 [ - + ]: 4 : memset(connect_data.hostnqn, 'b', sizeof(connect_data.hostnqn));
621 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
622 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
623 : 4 : poll_threads();
624 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
625 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
626 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
627 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1);
628 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 512);
629 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
630 [ - + ]: 4 : snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn);
631 : :
632 : : /* Host not allowed */
633 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
634 : 4 : MOCK_SET(spdk_nvmf_subsystem_host_allowed, false);
635 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
636 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
637 : 4 : poll_threads();
638 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
639 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
640 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_HOST);
641 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
642 : 4 : MOCK_SET(spdk_nvmf_subsystem_host_allowed, true);
643 : :
644 : : /* Invalid sqsize == 0 */
645 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
646 : 4 : cmd.connect_cmd.sqsize = 0;
647 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
648 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
649 : 4 : poll_threads();
650 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
651 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
652 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
653 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
654 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44);
655 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
656 : 4 : cmd.connect_cmd.sqsize = 31;
657 : :
658 : : /* Invalid admin sqsize > max_aq_depth */
659 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
660 : 4 : cmd.connect_cmd.sqsize = 32;
661 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
662 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
663 : 4 : poll_threads();
664 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
665 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
666 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
667 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
668 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44);
669 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
670 : 4 : cmd.connect_cmd.sqsize = 31;
671 : :
672 : : /* Invalid I/O sqsize > max_queue_depth */
673 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
674 : 4 : cmd.connect_cmd.qid = 1;
675 : 4 : cmd.connect_cmd.sqsize = 64;
676 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
677 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
678 : 4 : poll_threads();
679 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
680 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
681 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
682 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
683 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44);
684 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
685 : 4 : cmd.connect_cmd.qid = 0;
686 : 4 : cmd.connect_cmd.sqsize = 31;
687 : :
688 : : /* Invalid cntlid for admin queue */
689 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
690 : 4 : connect_data.cntlid = 0x1234;
691 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
692 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
693 : 4 : poll_threads();
694 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
695 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
696 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
697 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1);
698 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16);
699 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
700 : 4 : connect_data.cntlid = 0xFFFF;
701 : :
702 : 4 : ctrlr.admin_qpair = &admin_qpair;
703 : 4 : ctrlr.subsys = &subsystem;
704 : :
705 : : /* Valid I/O queue connect command */
706 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
707 : 4 : MOCK_SET(nvmf_subsystem_get_ctrlr, &ctrlr);
708 : 4 : cmd.connect_cmd.qid = 1;
709 : 4 : cmd.connect_cmd.sqsize = 63;
710 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
711 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
712 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
713 : 4 : poll_threads();
714 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
715 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
716 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
717 : 4 : CU_ASSERT(qpair.ctrlr == &ctrlr);
718 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
719 : 4 : qpair.ctrlr = NULL;
720 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
721 : 4 : cmd.connect_cmd.sqsize = 31;
722 : :
723 : : /* Non-existent controller */
724 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
725 : 4 : MOCK_SET(nvmf_subsystem_get_ctrlr, NULL);
726 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
727 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
728 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
729 : 4 : poll_threads();
730 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
731 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
732 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
733 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1);
734 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16);
735 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
736 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
737 : 4 : MOCK_SET(nvmf_subsystem_get_ctrlr, &ctrlr);
738 : :
739 : : /* I/O connect to discovery controller */
740 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
741 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT;
742 : 4 : MOCK_SET(spdk_nvmf_subsystem_is_discovery, true);
743 : 4 : subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
744 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
745 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
746 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
747 : 4 : poll_threads();
748 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
749 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
750 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
751 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
752 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42);
753 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
754 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
755 : :
756 : : /* I/O connect to discovery controller with keep-alive-timeout != 0 */
757 : 4 : cmd.connect_cmd.qid = 0;
758 : 4 : cmd.connect_cmd.kato = 120000;
759 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
760 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT;
761 : 4 : MOCK_SET(spdk_nvmf_subsystem_is_discovery, true);
762 : 4 : subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
763 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
764 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
765 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
766 : 4 : poll_threads();
767 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
768 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
769 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
770 : 4 : CU_ASSERT(qpair.ctrlr != NULL);
771 : 4 : CU_ASSERT(qpair.ctrlr->keep_alive_poller != NULL);
772 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
773 : 4 : nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr);
774 : 4 : spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
775 : 4 : free(qpair.ctrlr->visible_ns);
776 : 4 : free(qpair.ctrlr);
777 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
778 : 4 : qpair.ctrlr = NULL;
779 : :
780 : : /* I/O connect to discovery controller with keep-alive-timeout == 0.
781 : : * Then, a fixed timeout value is set to keep-alive-timeout.
782 : : */
783 : 4 : cmd.connect_cmd.kato = 0;
784 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
785 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT;
786 : 4 : MOCK_SET(spdk_nvmf_subsystem_is_discovery, true);
787 : 4 : subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
788 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
789 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
790 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
791 : 4 : poll_threads();
792 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
793 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
794 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
795 : 4 : CU_ASSERT(qpair.ctrlr != NULL);
796 : 4 : CU_ASSERT(qpair.ctrlr->keep_alive_poller != NULL);
797 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
798 : 4 : nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr);
799 : 4 : spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
800 : 4 : free(qpair.ctrlr->visible_ns);
801 : 4 : free(qpair.ctrlr);
802 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
803 : 4 : qpair.ctrlr = NULL;
804 : 4 : cmd.connect_cmd.qid = 1;
805 : 4 : cmd.connect_cmd.kato = 120000;
806 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
807 : 4 : MOCK_SET(spdk_nvmf_subsystem_is_discovery, false);
808 : :
809 : : /* I/O connect to disabled controller */
810 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
811 : 4 : ctrlr.vcprop.cc.bits.en = 0;
812 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
813 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
814 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
815 : 4 : poll_threads();
816 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
817 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
818 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
819 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
820 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42);
821 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
822 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
823 : 4 : ctrlr.vcprop.cc.bits.en = 1;
824 : :
825 : : /* I/O connect with invalid IOSQES */
826 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
827 : 4 : ctrlr.vcprop.cc.bits.iosqes = 3;
828 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
829 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
830 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
831 : 4 : poll_threads();
832 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
833 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
834 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
835 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
836 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42);
837 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
838 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
839 : 4 : ctrlr.vcprop.cc.bits.iosqes = 6;
840 : :
841 : : /* I/O connect with invalid IOCQES */
842 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
843 : 4 : ctrlr.vcprop.cc.bits.iocqes = 3;
844 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
845 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
846 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
847 : 4 : poll_threads();
848 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
849 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
850 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
851 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0);
852 : 4 : CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42);
853 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
854 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
855 : 4 : ctrlr.vcprop.cc.bits.iocqes = 4;
856 : :
857 : : /* I/O connect with qid that is too large */
858 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
859 : 4 : cmd.connect_cmd.qid = 3;
860 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
861 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
862 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
863 : 4 : poll_threads();
864 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
865 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
866 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER);
867 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
868 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
869 : :
870 : : /* I/O connect with duplicate queue ID */
871 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
872 : 4 : spdk_bit_array_set(ctrlr.qpair_mask, 1);
873 : 4 : cmd.connect_cmd.qid = 1;
874 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
875 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
876 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
877 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
878 : 4 : poll_threads();
879 : : /* First time, it will detect duplicate QID and schedule a retry. So for
880 : : * now we should expect the response to still be all zeroes.
881 : : */
882 : 4 : CU_ASSERT(spdk_mem_all_zero(&rsp, sizeof(rsp)));
883 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 1);
884 : :
885 : : /* Now advance the clock, so that the retry poller executes. */
886 : 4 : spdk_delay_us(DUPLICATE_QID_RETRY_US * 2);
887 : 4 : poll_threads();
888 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
889 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER);
890 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
891 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
892 : :
893 : : /* I/O connect with temporarily duplicate queue ID. This covers race
894 : : * where qpair_mask bit may not yet be cleared, even though initiator
895 : : * has closed the connection. See issue #2955. */
896 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
897 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
898 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
899 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
900 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
901 : 4 : poll_threads();
902 : : /* First time, it will detect duplicate QID and schedule a retry. So for
903 : : * now we should expect the response to still be all zeroes.
904 : : */
905 : 4 : CU_ASSERT(spdk_mem_all_zero(&rsp, sizeof(rsp)));
906 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 1);
907 : :
908 : : /* Now advance the clock, so that the retry poller executes. */
909 : 4 : spdk_bit_array_clear(ctrlr.qpair_mask, 1);
910 : 4 : spdk_delay_us(DUPLICATE_QID_RETRY_US * 2);
911 : 4 : poll_threads();
912 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
913 : 4 : CU_ASSERT(qpair.state == SPDK_NVMF_QPAIR_ENABLED);
914 : 4 : CU_ASSERT(qpair.ctrlr == &ctrlr);
915 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
916 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
917 : 4 : qpair.ctrlr = NULL;
918 : :
919 : : /* I/O connect when admin qpair is being destroyed */
920 : 4 : admin_qpair.group = NULL;
921 : 4 : admin_qpair.state = SPDK_NVMF_QPAIR_DEACTIVATING;
922 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
923 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
924 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
925 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
926 : 4 : poll_threads();
927 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
928 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
929 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
930 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
931 : 4 : admin_qpair.group = &group;
932 : 4 : admin_qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
933 : :
934 : : /* I/O connect when admin qpair was destroyed */
935 : 4 : ctrlr.admin_qpair = NULL;
936 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
937 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
938 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
939 : 4 : rc = nvmf_ctrlr_cmd_connect(&req);
940 : 4 : poll_threads();
941 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
942 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
943 : 4 : CU_ASSERT(qpair.ctrlr == NULL);
944 : 4 : CU_ASSERT(sgroups[subsystem.id].mgmt_io_outstanding == 0);
945 : 4 : ctrlr.admin_qpair = &admin_qpair;
946 : :
947 : : /* Clean up globals */
948 [ - + - + ]: 4 : MOCK_CLEAR(spdk_nvmf_tgt_find_subsystem);
949 [ - + - + ]: 4 : MOCK_CLEAR(spdk_nvmf_poll_group_create);
950 : :
951 : 4 : spdk_bit_array_free(&ctrlr.qpair_mask);
952 : 4 : free(sgroups);
953 : 4 : }
954 : :
955 : : static void
956 : 4 : test_get_ns_id_desc_list(void)
957 : : {
958 : 3 : struct spdk_nvmf_subsystem subsystem;
959 : 3 : struct spdk_nvmf_qpair qpair;
960 : 3 : struct spdk_nvmf_ctrlr ctrlr;
961 : 3 : struct spdk_nvmf_request req;
962 : 3 : struct spdk_nvmf_ns *ns_ptrs[1];
963 : 3 : struct spdk_nvmf_ns ns;
964 : 3 : union nvmf_h2c_msg cmd;
965 : 3 : union nvmf_c2h_msg rsp;
966 : 3 : struct spdk_bdev bdev;
967 : 3 : uint8_t buf[4096];
968 : :
969 [ - + ]: 4 : memset(&subsystem, 0, sizeof(subsystem));
970 : 4 : ns_ptrs[0] = &ns;
971 : 4 : subsystem.ns = ns_ptrs;
972 : 4 : subsystem.max_nsid = 1;
973 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
974 : :
975 [ - + ]: 4 : memset(&ns, 0, sizeof(ns));
976 : 4 : ns.opts.nsid = 1;
977 : 4 : ns.bdev = &bdev;
978 : :
979 [ - + ]: 4 : memset(&qpair, 0, sizeof(qpair));
980 : 4 : qpair.ctrlr = &ctrlr;
981 : :
982 [ - + ]: 4 : memset(&ctrlr, 0, sizeof(ctrlr));
983 : 4 : ctrlr.subsys = &subsystem;
984 : 4 : ctrlr.vcprop.cc.bits.en = 1;
985 : 4 : ctrlr.thread = spdk_get_thread();
986 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
987 : :
988 [ - + ]: 4 : memset(&req, 0, sizeof(req));
989 : 4 : req.qpair = &qpair;
990 : 4 : req.cmd = &cmd;
991 : 4 : req.rsp = &rsp;
992 : 4 : req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
993 : 4 : req.length = sizeof(buf);
994 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &buf, req.length);
995 : :
996 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
997 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_IDENTIFY;
998 : 4 : cmd.nvme_cmd.cdw10_bits.identify.cns = SPDK_NVME_IDENTIFY_NS_ID_DESCRIPTOR_LIST;
999 : :
1000 : : /* Invalid NSID */
1001 : 4 : cmd.nvme_cmd.nsid = 0;
1002 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1003 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1004 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1005 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1006 : :
1007 : : /* Valid NSID, but ns is inactive */
1008 : 4 : spdk_bit_array_clear(ctrlr.visible_ns, 0);
1009 : 4 : cmd.nvme_cmd.nsid = 1;
1010 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1011 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == 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_NAMESPACE_OR_FORMAT);
1014 : :
1015 : : /* Valid NSID, but ns has no IDs defined */
1016 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
1017 : 4 : cmd.nvme_cmd.nsid = 1;
1018 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1019 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1020 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1021 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1022 : 4 : CU_ASSERT(spdk_mem_all_zero(buf, sizeof(buf)));
1023 : :
1024 : : /* Valid NSID, only EUI64 defined */
1025 : 4 : ns.opts.eui64[0] = 0x11;
1026 : 4 : ns.opts.eui64[7] = 0xFF;
1027 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1028 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1029 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1030 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1031 : 4 : CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64);
1032 : 4 : CU_ASSERT(buf[1] == 8);
1033 : 4 : CU_ASSERT(buf[4] == 0x11);
1034 : 4 : CU_ASSERT(buf[11] == 0xFF);
1035 : 4 : CU_ASSERT(buf[13] == 0);
1036 : :
1037 : : /* Valid NSID, only NGUID defined */
1038 [ - + ]: 4 : memset(ns.opts.eui64, 0, sizeof(ns.opts.eui64));
1039 : 4 : ns.opts.nguid[0] = 0x22;
1040 : 4 : ns.opts.nguid[15] = 0xEE;
1041 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1042 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1043 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1044 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1045 : 4 : CU_ASSERT(buf[0] == SPDK_NVME_NIDT_NGUID);
1046 : 4 : CU_ASSERT(buf[1] == 16);
1047 : 4 : CU_ASSERT(buf[4] == 0x22);
1048 : 4 : CU_ASSERT(buf[19] == 0xEE);
1049 : 4 : CU_ASSERT(buf[21] == 0);
1050 : :
1051 : : /* Valid NSID, both EUI64 and NGUID defined */
1052 : 4 : ns.opts.eui64[0] = 0x11;
1053 : 4 : ns.opts.eui64[7] = 0xFF;
1054 : 4 : ns.opts.nguid[0] = 0x22;
1055 : 4 : ns.opts.nguid[15] = 0xEE;
1056 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1057 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1058 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1059 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1060 : 4 : CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64);
1061 : 4 : CU_ASSERT(buf[1] == 8);
1062 : 4 : CU_ASSERT(buf[4] == 0x11);
1063 : 4 : CU_ASSERT(buf[11] == 0xFF);
1064 : 4 : CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID);
1065 : 4 : CU_ASSERT(buf[13] == 16);
1066 : 4 : CU_ASSERT(buf[16] == 0x22);
1067 : 4 : CU_ASSERT(buf[31] == 0xEE);
1068 : 4 : CU_ASSERT(buf[33] == 0);
1069 : :
1070 : : /* Valid NSID, EUI64, NGUID, and UUID defined */
1071 : 4 : ns.opts.eui64[0] = 0x11;
1072 : 4 : ns.opts.eui64[7] = 0xFF;
1073 : 4 : ns.opts.nguid[0] = 0x22;
1074 : 4 : ns.opts.nguid[15] = 0xEE;
1075 : 4 : ns.opts.uuid.u.raw[0] = 0x33;
1076 : 4 : ns.opts.uuid.u.raw[15] = 0xDD;
1077 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1078 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1079 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1080 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1081 : 4 : CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64);
1082 : 4 : CU_ASSERT(buf[1] == 8);
1083 : 4 : CU_ASSERT(buf[4] == 0x11);
1084 : 4 : CU_ASSERT(buf[11] == 0xFF);
1085 : 4 : CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID);
1086 : 4 : CU_ASSERT(buf[13] == 16);
1087 : 4 : CU_ASSERT(buf[16] == 0x22);
1088 : 4 : CU_ASSERT(buf[31] == 0xEE);
1089 : 4 : CU_ASSERT(buf[32] == SPDK_NVME_NIDT_UUID);
1090 : 4 : CU_ASSERT(buf[33] == 16);
1091 : 4 : CU_ASSERT(buf[36] == 0x33);
1092 : 4 : CU_ASSERT(buf[51] == 0xDD);
1093 : 4 : CU_ASSERT(buf[53] == 0);
1094 : :
1095 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
1096 : 4 : }
1097 : :
1098 : : static void
1099 : 4 : test_identify_ns(void)
1100 : : {
1101 : 4 : struct spdk_nvmf_subsystem subsystem = {};
1102 : 4 : struct spdk_nvmf_transport transport = {};
1103 : 4 : struct spdk_nvmf_qpair admin_qpair = { .transport = &transport};
1104 : 4 : struct spdk_nvmf_ctrlr ctrlr = {
1105 : : .subsys = &subsystem,
1106 : : .admin_qpair = &admin_qpair,
1107 : : };
1108 : 4 : struct spdk_nvme_cmd cmd = {};
1109 : 4 : struct spdk_nvme_cpl rsp = {};
1110 : 4 : struct spdk_nvme_ns_data nsdata = {};
1111 : 4 : struct spdk_bdev bdev[3] = {{.blockcnt = 1234}, {.blockcnt = 0}, {.blockcnt = 5678}};
1112 : 4 : struct spdk_nvmf_ns ns[3] = {{.bdev = &bdev[0]}, {.bdev = NULL}, {.bdev = &bdev[2]}};
1113 : 4 : struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]};
1114 : :
1115 : 4 : ctrlr.visible_ns = spdk_bit_array_create(3);
1116 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
1117 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 2);
1118 : :
1119 : 4 : subsystem.ns = ns_arr;
1120 : 4 : subsystem.max_nsid = SPDK_COUNTOF(ns_arr);
1121 : :
1122 : : /* Invalid NSID 0 */
1123 : 4 : cmd.nsid = 0;
1124 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1125 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1126 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1127 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1128 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1129 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1130 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata)));
1131 : :
1132 : : /* Valid NSID 1 */
1133 : 4 : cmd.nsid = 1;
1134 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1135 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1136 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1137 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1138 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1139 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1140 : 4 : CU_ASSERT(nsdata.nsze == 1234);
1141 : :
1142 : : /* Valid but inactive NSID 1 */
1143 : 4 : spdk_bit_array_clear(ctrlr.visible_ns, 0);
1144 : 4 : cmd.nsid = 1;
1145 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1146 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1147 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1148 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1149 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1150 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1151 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata)));
1152 : :
1153 : : /* Valid but unallocated NSID 2 */
1154 : 4 : cmd.nsid = 2;
1155 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1156 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1157 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1158 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1159 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1160 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1161 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata)));
1162 : :
1163 : : /* Valid NSID 3 */
1164 : 4 : cmd.nsid = 3;
1165 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1166 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1167 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1168 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1169 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1170 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1171 : 4 : CU_ASSERT(nsdata.nsze == 5678);
1172 : :
1173 : : /* Invalid NSID 4 */
1174 : 4 : cmd.nsid = 4;
1175 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1176 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1177 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1178 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1179 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1180 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1181 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata)));
1182 : :
1183 : : /* Invalid NSID 0xFFFFFFFF (NS management not supported) */
1184 : 4 : cmd.nsid = 0xFFFFFFFF;
1185 [ - + ]: 4 : memset(&nsdata, 0, sizeof(nsdata));
1186 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1187 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
1188 : : &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1189 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1190 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1191 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata)));
1192 : :
1193 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
1194 : 4 : }
1195 : :
1196 : : static void
1197 : 4 : test_identify_ns_iocs_specific(void)
1198 : : {
1199 : 4 : struct spdk_nvmf_subsystem subsystem = {};
1200 : 4 : struct spdk_nvmf_transport transport = {};
1201 : 4 : struct spdk_nvmf_qpair admin_qpair = { .transport = &transport };
1202 : 4 : struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair };
1203 : 4 : struct spdk_nvme_cmd cmd = {};
1204 : 4 : struct spdk_nvme_cpl rsp = {};
1205 : 4 : struct spdk_nvme_zns_ns_data nsdata_zns = {};
1206 : 4 : struct spdk_nvme_nvm_ns_data nsdata_nvm = {};
1207 : 4 : struct spdk_bdev bdev[2] = {{.blockcnt = 1234, .zoned = true, .zone_size = ZONE_SIZE, .max_open_zones = MAX_OPEN_ZONES, .max_active_zones = MAX_ACTIVE_ZONES}, {.blockcnt = 5678}};
1208 : 4 : struct spdk_nvmf_ns ns[2] = {{.bdev = &bdev[0]}, {.bdev = &bdev[1]}};
1209 : 4 : struct spdk_nvmf_ns *ns_arr[2] = {&ns[0], &ns[1]};
1210 : :
1211 : 4 : ctrlr.visible_ns = spdk_bit_array_create(3);
1212 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
1213 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 1);
1214 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 2);
1215 : 4 : subsystem.ns = ns_arr;
1216 : 4 : subsystem.max_nsid = SPDK_COUNTOF(ns_arr);
1217 : :
1218 : 4 : cmd.cdw11_bits.identify.csi = SPDK_NVME_CSI_ZNS;
1219 : :
1220 : : /* Invalid ZNS NSID 0 */
1221 : 4 : cmd.nsid = 0;
1222 [ - + ]: 4 : memset(&nsdata_zns, 0xFF, sizeof(nsdata_zns));
1223 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1224 : 4 : CU_ASSERT(spdk_nvmf_ns_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1225 : : &nsdata_zns, sizeof(nsdata_zns)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1226 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1227 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1228 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata_zns, sizeof(nsdata_zns)));
1229 : :
1230 : : /* Valid ZNS NSID 1 */
1231 : 4 : cmd.nsid = 1;
1232 [ - + ]: 4 : memset(&nsdata_zns, 0xFF, sizeof(nsdata_zns));
1233 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1234 : 4 : CU_ASSERT(spdk_nvmf_ns_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1235 : : &nsdata_zns, sizeof(nsdata_zns)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1236 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1237 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1238 : 4 : CU_ASSERT(nsdata_zns.ozcs.read_across_zone_boundaries == 1);
1239 : 4 : CU_ASSERT(nsdata_zns.mar == MAX_ACTIVE_ZONES - 1);
1240 : 4 : CU_ASSERT(nsdata_zns.mor == MAX_OPEN_ZONES - 1);
1241 : 4 : CU_ASSERT(nsdata_zns.lbafe[0].zsze == ZONE_SIZE);
1242 : 4 : nsdata_zns.ozcs.read_across_zone_boundaries = 0;
1243 : 4 : nsdata_zns.mar = 0;
1244 : 4 : nsdata_zns.mor = 0;
1245 : 4 : nsdata_zns.lbafe[0].zsze = 0;
1246 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata_zns, sizeof(nsdata_zns)));
1247 : :
1248 : 4 : cmd.cdw11_bits.identify.csi = SPDK_NVME_CSI_NVM;
1249 : :
1250 : : /* Valid NVM NSID 2 with DIF type 1 */
1251 : 4 : bdev[1].dif_type = SPDK_DIF_TYPE1;
1252 : 4 : cmd.nsid = 2;
1253 [ - + ]: 4 : memset(&nsdata_nvm, 0xFF, sizeof(nsdata_nvm));
1254 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1255 : 4 : CU_ASSERT(spdk_nvmf_ns_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1256 : : &nsdata_nvm, sizeof(nsdata_nvm)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1257 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1258 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1259 : 4 : CU_ASSERT(nsdata_nvm.lbstm == 0);
1260 : 4 : CU_ASSERT(nsdata_nvm.pic._16bpists == 0);
1261 : 4 : CU_ASSERT(nsdata_nvm.pic._16bpistm == 1);
1262 : 4 : CU_ASSERT(nsdata_nvm.pic.stcrs == 0);
1263 : 4 : CU_ASSERT(nsdata_nvm.elbaf[0].sts == 16);
1264 : 4 : CU_ASSERT(nsdata_nvm.elbaf[0].pif == SPDK_DIF_PI_FORMAT_32);
1265 : 4 : nsdata_nvm.pic._16bpistm = 0;
1266 : 4 : nsdata_nvm.elbaf[0].sts = 0;
1267 : 4 : nsdata_nvm.elbaf[0].pif = 0;
1268 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata_nvm, sizeof(nsdata_nvm)));
1269 : :
1270 : : /* Invalid NVM NSID 3 */
1271 : 4 : cmd.nsid = 0;
1272 [ - + ]: 4 : memset(&nsdata_nvm, 0xFF, sizeof(nsdata_nvm));
1273 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1274 : 4 : CU_ASSERT(spdk_nvmf_ns_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1275 : : &nsdata_nvm, sizeof(nsdata_nvm)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1276 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1277 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
1278 : 4 : CU_ASSERT(spdk_mem_all_zero(&nsdata_nvm, sizeof(nsdata_nvm)));
1279 : :
1280 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
1281 : 4 : }
1282 : :
1283 : : static void
1284 : 4 : test_set_get_features(void)
1285 : : {
1286 : 4 : struct spdk_nvmf_subsystem subsystem = {};
1287 : 4 : struct spdk_nvmf_qpair admin_qpair = {};
1288 : 3 : enum spdk_nvme_ana_state ana_state[3];
1289 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
1290 : 4 : struct spdk_nvmf_ctrlr ctrlr = {
1291 : : .subsys = &subsystem,
1292 : : .admin_qpair = &admin_qpair,
1293 : : .listener = &listener
1294 : : };
1295 : 4 : union nvmf_h2c_msg cmd = {};
1296 : 4 : union nvmf_c2h_msg rsp = {};
1297 : 3 : struct spdk_nvmf_ns ns[3];
1298 : 4 : struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]};
1299 : 3 : struct spdk_nvmf_request req;
1300 : : int rc;
1301 : :
1302 : 4 : ctrlr.visible_ns = spdk_bit_array_create(3);
1303 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
1304 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 2);
1305 : 4 : ns[0].anagrpid = 1;
1306 : 4 : ns[2].anagrpid = 3;
1307 : 4 : subsystem.ns = ns_arr;
1308 : 4 : subsystem.max_nsid = SPDK_COUNTOF(ns_arr);
1309 : 4 : listener.ana_state[0] = SPDK_NVME_ANA_OPTIMIZED_STATE;
1310 : 4 : listener.ana_state[2] = SPDK_NVME_ANA_OPTIMIZED_STATE;
1311 : 4 : admin_qpair.ctrlr = &ctrlr;
1312 : 4 : req.qpair = &admin_qpair;
1313 : 4 : cmd.nvme_cmd.nsid = 1;
1314 : 4 : req.cmd = &cmd;
1315 : 4 : req.rsp = &rsp;
1316 : :
1317 : : /* Set SPDK_NVME_FEAT_HOST_RESERVE_PERSIST feature */
1318 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1319 : 4 : cmd.nvme_cmd.cdw11_bits.feat_rsv_persistence.bits.ptpl = 1;
1320 : 4 : ns[0].ptpl_file = "testcfg";
1321 : 4 : rc = nvmf_ctrlr_set_features_reservation_persistence(&req);
1322 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1323 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
1324 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_FEATURE_ID_NOT_SAVEABLE);
1325 [ - + ]: 4 : CU_ASSERT(ns[0].ptpl_activated == true);
1326 : :
1327 : : /* Get SPDK_NVME_FEAT_HOST_RESERVE_PERSIST feature */
1328 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES;
1329 : 4 : cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_HOST_RESERVE_PERSIST;
1330 : 4 : rc = nvmf_ctrlr_get_features_reservation_persistence(&req);
1331 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1332 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1333 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1334 : 4 : CU_ASSERT(rsp.nvme_cpl.cdw0 == 1);
1335 : :
1336 : :
1337 : : /* Get SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - valid TMPSEL */
1338 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES;
1339 : 4 : cmd.nvme_cmd.cdw11 = 0x42;
1340 : 4 : cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD;
1341 : :
1342 : 4 : rc = nvmf_ctrlr_get_features(&req);
1343 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1344 : :
1345 : : /* Get SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid TMPSEL */
1346 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES;
1347 : 4 : cmd.nvme_cmd.cdw11 = 0x42 | 1 << 16 | 1 << 19; /* Set reserved value */
1348 : 4 : cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD;
1349 : :
1350 : 4 : rc = nvmf_ctrlr_get_features(&req);
1351 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1352 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1353 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
1354 : :
1355 : : /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - valid TMPSEL */
1356 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1357 : 4 : cmd.nvme_cmd.cdw11 = 0x42;
1358 : 4 : cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD;
1359 : :
1360 : 4 : rc = nvmf_ctrlr_set_features(&req);
1361 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1362 : :
1363 : : /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid TMPSEL */
1364 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1365 : 4 : cmd.nvme_cmd.cdw11 = 0x42 | 1 << 16 | 1 << 19; /* Set reserved value */
1366 : 4 : cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD;
1367 : :
1368 : 4 : rc = nvmf_ctrlr_set_features(&req);
1369 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1370 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1371 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
1372 : :
1373 : : /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid THSEL */
1374 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1375 : 4 : cmd.nvme_cmd.cdw11 = 0x42;
1376 : 4 : cmd.nvme_cmd.cdw11_bits.feat_temp_threshold.bits.thsel = 0x3; /* Set reserved value */
1377 : 4 : cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD;
1378 : :
1379 : 4 : rc = nvmf_ctrlr_set_features(&req);
1380 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1381 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1382 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
1383 : :
1384 : :
1385 : : /* get SPDK_NVME_FEAT_ERROR_RECOVERY - generic */
1386 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1387 : 4 : cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY;
1388 : :
1389 : 4 : rc = nvmf_ctrlr_get_features(&req);
1390 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1391 : :
1392 : : /* Set SPDK_NVME_FEAT_ERROR_RECOVERY - DULBE set */
1393 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1394 : 4 : cmd.nvme_cmd.cdw11 = 0x42;
1395 : 4 : cmd.nvme_cmd.cdw11_bits.feat_error_recovery.bits.dulbe = 0x1;
1396 : 4 : cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY;
1397 : :
1398 : 4 : rc = nvmf_ctrlr_set_features(&req);
1399 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1400 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1401 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
1402 : :
1403 : : /* Set SPDK_NVME_FEAT_ERROR_RECOVERY - DULBE cleared */
1404 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
1405 : 4 : cmd.nvme_cmd.cdw11 = 0x42;
1406 : 4 : cmd.nvme_cmd.cdw11_bits.feat_error_recovery.bits.dulbe = 0x0;
1407 : 4 : cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY;
1408 : :
1409 : 4 : rc = nvmf_ctrlr_set_features(&req);
1410 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1411 : :
1412 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
1413 : 4 : }
1414 : :
1415 : : /*
1416 : : * Reservation Unit Test Configuration
1417 : : * -------- -------- --------
1418 : : * | Host A | | Host B | | Host C |
1419 : : * -------- -------- --------
1420 : : * / \ | |
1421 : : * -------- -------- ------- -------
1422 : : * |Ctrlr1_A| |Ctrlr2_A| |Ctrlr_B| |Ctrlr_C|
1423 : : * -------- -------- ------- -------
1424 : : * \ \ / /
1425 : : * \ \ / /
1426 : : * \ \ / /
1427 : : * --------------------------------------
1428 : : * | NAMESPACE 1 |
1429 : : * --------------------------------------
1430 : : */
1431 : :
1432 : : static struct spdk_nvmf_ctrlr g_ctrlr1_A, g_ctrlr2_A, g_ctrlr_B, g_ctrlr_C;
1433 : : struct spdk_nvmf_subsystem_pg_ns_info g_ns_info;
1434 : :
1435 : : static void
1436 : 24 : ut_reservation_init(enum spdk_nvme_reservation_type rtype)
1437 : : {
1438 : : /* Host A has two controllers */
1439 : 24 : spdk_uuid_generate(&g_ctrlr1_A.hostid);
1440 : 24 : spdk_uuid_copy(&g_ctrlr2_A.hostid, &g_ctrlr1_A.hostid);
1441 : :
1442 : : /* Host B has 1 controller */
1443 : 24 : spdk_uuid_generate(&g_ctrlr_B.hostid);
1444 : :
1445 : : /* Host C has 1 controller */
1446 : 24 : spdk_uuid_generate(&g_ctrlr_C.hostid);
1447 : :
1448 [ - + ]: 24 : memset(&g_ns_info, 0, sizeof(g_ns_info));
1449 : 24 : g_ns_info.rtype = rtype;
1450 : 24 : g_ns_info.reg_hostid[0] = g_ctrlr1_A.hostid;
1451 : 24 : g_ns_info.reg_hostid[1] = g_ctrlr_B.hostid;
1452 : 24 : g_ns_info.reg_hostid[2] = g_ctrlr_C.hostid;
1453 : 24 : }
1454 : :
1455 : : static void
1456 : 4 : test_reservation_write_exclusive(void)
1457 : : {
1458 : 4 : struct spdk_nvmf_request req = {};
1459 : 4 : union nvmf_h2c_msg cmd = {};
1460 : 4 : union nvmf_c2h_msg rsp = {};
1461 : : int rc;
1462 : :
1463 : 4 : req.cmd = &cmd;
1464 : 4 : req.rsp = &rsp;
1465 : :
1466 : : /* Host A holds reservation with type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE */
1467 : 4 : ut_reservation_init(SPDK_NVME_RESERVE_WRITE_EXCLUSIVE);
1468 : 4 : g_ns_info.holder_id = g_ctrlr1_A.hostid;
1469 : :
1470 : : /* Test Case: Issue a Read command from Host A and Host B */
1471 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1472 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req);
1473 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1474 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1475 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1476 : :
1477 : : /* Test Case: Issue a DSM Write command from Host A and Host B */
1478 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT;
1479 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req);
1480 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1481 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1482 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc < 0);
1483 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1484 : :
1485 : : /* Test Case: Issue a Write command from Host C */
1486 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
1487 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1488 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc < 0);
1489 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1490 : :
1491 : : /* Test Case: Issue a Read command from Host B */
1492 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1493 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1494 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1495 : :
1496 : : /* Unregister Host C */
1497 : 4 : spdk_uuid_set_null(&g_ns_info.reg_hostid[2]);
1498 : :
1499 : : /* Test Case: Read and Write commands from non-registrant Host C */
1500 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
1501 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1502 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc < 0);
1503 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1504 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1505 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1506 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1507 : 4 : }
1508 : :
1509 : : static void
1510 : 4 : test_reservation_exclusive_access(void)
1511 : : {
1512 : 4 : struct spdk_nvmf_request req = {};
1513 : 4 : union nvmf_h2c_msg cmd = {};
1514 : 4 : union nvmf_c2h_msg rsp = {};
1515 : : int rc;
1516 : :
1517 : 4 : req.cmd = &cmd;
1518 : 4 : req.rsp = &rsp;
1519 : :
1520 : : /* Host A holds reservation with type SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS */
1521 : 4 : ut_reservation_init(SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS);
1522 : 4 : g_ns_info.holder_id = g_ctrlr1_A.hostid;
1523 : :
1524 : : /* Test Case: Issue a Read command from Host B */
1525 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1526 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1527 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rc < 0);
1528 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1529 : :
1530 : : /* Test Case: Issue a Reservation Release command from a valid Registrant */
1531 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_RESERVATION_RELEASE;
1532 : 4 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1533 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == 0);
1534 : 4 : }
1535 : :
1536 : : static void
1537 : 8 : _test_reservation_write_exclusive_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype)
1538 : : {
1539 : 8 : struct spdk_nvmf_request req = {};
1540 : 8 : union nvmf_h2c_msg cmd = {};
1541 : 8 : union nvmf_c2h_msg rsp = {};
1542 : : int rc;
1543 : :
1544 : 8 : req.cmd = &cmd;
1545 : 8 : req.rsp = &rsp;
1546 : :
1547 : : /* SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY and SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS */
1548 : 8 : ut_reservation_init(rtype);
1549 : 8 : g_ns_info.holder_id = g_ctrlr1_A.hostid;
1550 : :
1551 : : /* Test Case: Issue a Read command from Host A and Host C */
1552 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1553 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req);
1554 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1555 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1556 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1557 : :
1558 : : /* Test Case: Issue a DSM Write command from Host A and Host C */
1559 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT;
1560 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req);
1561 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1562 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1563 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1564 : :
1565 : : /* Unregister Host C */
1566 : 8 : spdk_uuid_set_null(&g_ns_info.reg_hostid[2]);
1567 : :
1568 : : /* Test Case: Read and Write commands from non-registrant Host C */
1569 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1570 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1571 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1572 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
1573 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req);
1574 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc < 0);
1575 [ - + ]: 8 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1576 : 8 : }
1577 : :
1578 : : static void
1579 : 4 : test_reservation_write_exclusive_regs_only_and_all_regs(void)
1580 : : {
1581 : 4 : _test_reservation_write_exclusive_regs_only_and_all_regs(
1582 : : SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY);
1583 : 4 : _test_reservation_write_exclusive_regs_only_and_all_regs(
1584 : : SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS);
1585 : 4 : }
1586 : :
1587 : : static void
1588 : 8 : _test_reservation_exclusive_access_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype)
1589 : : {
1590 : 8 : struct spdk_nvmf_request req = {};
1591 : 8 : union nvmf_h2c_msg cmd = {};
1592 : 8 : union nvmf_c2h_msg rsp = {};
1593 : : int rc;
1594 : :
1595 : 8 : req.cmd = &cmd;
1596 : 8 : req.rsp = &rsp;
1597 : :
1598 : : /* SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY and SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS */
1599 : 8 : ut_reservation_init(rtype);
1600 : 8 : g_ns_info.holder_id = g_ctrlr1_A.hostid;
1601 : :
1602 : : /* Test Case: Issue a Write command from Host B */
1603 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
1604 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1605 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc == 0);
1606 : :
1607 : : /* Unregister Host B */
1608 : 8 : spdk_uuid_set_null(&g_ns_info.reg_hostid[1]);
1609 : :
1610 : : /* Test Case: Issue a Read command from Host B */
1611 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
1612 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1613 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc < 0);
1614 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1615 : 8 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
1616 : 8 : rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req);
1617 [ + + ]: 8 : SPDK_CU_ASSERT_FATAL(rc < 0);
1618 [ - + ]: 8 : SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT);
1619 : 8 : }
1620 : :
1621 : : static void
1622 : 4 : test_reservation_exclusive_access_regs_only_and_all_regs(void)
1623 : : {
1624 : 4 : _test_reservation_exclusive_access_regs_only_and_all_regs(
1625 : : SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY);
1626 : 4 : _test_reservation_exclusive_access_regs_only_and_all_regs(
1627 : : SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS);
1628 : 4 : }
1629 : :
1630 : : static void
1631 : 12 : init_pending_async_events(struct spdk_nvmf_ctrlr *ctrlr)
1632 : : {
1633 : 12 : STAILQ_INIT(&ctrlr->async_events);
1634 : 12 : }
1635 : :
1636 : : static void
1637 : 12 : cleanup_pending_async_events(struct spdk_nvmf_ctrlr *ctrlr)
1638 : : {
1639 : : struct spdk_nvmf_async_event_completion *event, *event_tmp;
1640 : :
1641 [ + + + + ]: 16 : STAILQ_FOREACH_SAFE(event, &ctrlr->async_events, link, event_tmp) {
1642 [ + + + + : 4 : STAILQ_REMOVE(&ctrlr->async_events, event, spdk_nvmf_async_event_completion, link);
- - - - ]
1643 : 4 : free(event);
1644 : 1 : }
1645 : 12 : }
1646 : :
1647 : : static int
1648 : 16 : num_pending_async_events(struct spdk_nvmf_ctrlr *ctrlr)
1649 : : {
1650 : 16 : int num = 0;
1651 : : struct spdk_nvmf_async_event_completion *event;
1652 : :
1653 [ + + ]: 24 : STAILQ_FOREACH(event, &ctrlr->async_events, link) {
1654 : 8 : num++;
1655 : 2 : }
1656 : 16 : return num;
1657 : : }
1658 : :
1659 : : static void
1660 : 4 : test_reservation_notification_log_page(void)
1661 : : {
1662 : 3 : struct spdk_nvmf_ctrlr ctrlr;
1663 : 3 : struct spdk_nvmf_qpair qpair;
1664 : 3 : struct spdk_nvmf_ns ns;
1665 : 4 : struct spdk_nvmf_request req = {};
1666 : 4 : union nvmf_h2c_msg cmd = {};
1667 : 4 : union nvmf_c2h_msg rsp = {};
1668 : 4 : union spdk_nvme_async_event_completion event = {};
1669 : 3 : struct spdk_nvme_reservation_notification_log logs[3];
1670 : 3 : struct iovec iov;
1671 : :
1672 [ - + ]: 4 : memset(&ctrlr, 0, sizeof(ctrlr));
1673 : 4 : ctrlr.thread = spdk_get_thread();
1674 : 4 : TAILQ_INIT(&ctrlr.log_head);
1675 : 4 : init_pending_async_events(&ctrlr);
1676 : 4 : ns.nsid = 1;
1677 : :
1678 : : /* Test Case: Mask all the reservation notifications */
1679 : 4 : ns.mask = SPDK_NVME_REGISTRATION_PREEMPTED_MASK |
1680 : : SPDK_NVME_RESERVATION_RELEASED_MASK |
1681 : : SPDK_NVME_RESERVATION_PREEMPTED_MASK;
1682 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1683 : : SPDK_NVME_REGISTRATION_PREEMPTED);
1684 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1685 : : SPDK_NVME_RESERVATION_RELEASED);
1686 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1687 : : SPDK_NVME_RESERVATION_PREEMPTED);
1688 : 4 : poll_threads();
1689 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&ctrlr.log_head));
1690 : :
1691 : : /* Test Case: Unmask all the reservation notifications,
1692 : : * 3 log pages are generated, and AER was triggered.
1693 : : */
1694 : 4 : ns.mask = 0;
1695 : 4 : ctrlr.num_avail_log_pages = 0;
1696 : 4 : req.cmd = &cmd;
1697 : 4 : req.rsp = &rsp;
1698 : 4 : ctrlr.aer_req[0] = &req;
1699 : 4 : ctrlr.nr_aer_reqs = 1;
1700 : 4 : req.qpair = &qpair;
1701 : 4 : TAILQ_INIT(&qpair.outstanding);
1702 : 4 : qpair.ctrlr = NULL;
1703 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
1704 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
1705 : :
1706 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1707 : : SPDK_NVME_REGISTRATION_PREEMPTED);
1708 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1709 : : SPDK_NVME_RESERVATION_RELEASED);
1710 : 4 : nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
1711 : : SPDK_NVME_RESERVATION_PREEMPTED);
1712 : 4 : poll_threads();
1713 : 4 : event.raw = rsp.nvme_cpl.cdw0;
1714 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(event.bits.async_event_type == SPDK_NVME_ASYNC_EVENT_TYPE_IO);
1715 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_RESERVATION_LOG_AVAIL);
1716 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(event.bits.log_page_identifier == SPDK_NVME_LOG_RESERVATION_NOTIFICATION);
1717 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 3);
1718 : :
1719 : : /* Test Case: Get Log Page to clear the log pages */
1720 : 4 : iov.iov_base = &logs[0];
1721 : 4 : iov.iov_len = sizeof(logs);
1722 : 4 : nvmf_get_reservation_notification_log_page(&ctrlr, &iov, 1, 0, sizeof(logs), 0);
1723 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 0);
1724 : :
1725 : 4 : cleanup_pending_async_events(&ctrlr);
1726 : 4 : }
1727 : :
1728 : : static void
1729 : 4 : test_get_dif_ctx(void)
1730 : : {
1731 : 4 : struct spdk_nvmf_subsystem subsystem = {};
1732 : 4 : struct spdk_nvmf_request req = {};
1733 : 4 : struct spdk_nvmf_qpair qpair = {};
1734 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
1735 : 4 : struct spdk_nvmf_ns ns = {};
1736 : 4 : struct spdk_nvmf_ns *_ns = NULL;
1737 : 4 : struct spdk_bdev bdev = {};
1738 : 4 : union nvmf_h2c_msg cmd = {};
1739 : 4 : struct spdk_dif_ctx dif_ctx = {};
1740 : : bool ret;
1741 : :
1742 : 4 : ctrlr.subsys = &subsystem;
1743 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
1744 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
1745 : :
1746 : 4 : qpair.ctrlr = &ctrlr;
1747 : :
1748 : 4 : req.qpair = &qpair;
1749 : 4 : req.cmd = &cmd;
1750 : :
1751 : 4 : ns.bdev = &bdev;
1752 : :
1753 : 4 : ctrlr.dif_insert_or_strip = false;
1754 : :
1755 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1756 : 4 : CU_ASSERT(ret == false);
1757 : :
1758 : 4 : ctrlr.dif_insert_or_strip = true;
1759 : 4 : qpair.state = SPDK_NVMF_QPAIR_UNINITIALIZED;
1760 : :
1761 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1762 : 4 : CU_ASSERT(ret == false);
1763 : :
1764 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
1765 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FABRIC;
1766 : :
1767 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1768 : 4 : CU_ASSERT(ret == false);
1769 : :
1770 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FLUSH;
1771 : :
1772 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1773 : 4 : CU_ASSERT(ret == false);
1774 : :
1775 : 4 : qpair.qid = 1;
1776 : :
1777 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1778 : 4 : CU_ASSERT(ret == false);
1779 : :
1780 : 4 : cmd.nvme_cmd.nsid = 1;
1781 : :
1782 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1783 : 4 : CU_ASSERT(ret == false);
1784 : :
1785 : 4 : subsystem.max_nsid = 1;
1786 : 4 : subsystem.ns = &_ns;
1787 : 4 : subsystem.ns[0] = &ns;
1788 : :
1789 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1790 : 4 : CU_ASSERT(ret == false);
1791 : :
1792 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_WRITE;
1793 : :
1794 : 4 : ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx);
1795 : 4 : CU_ASSERT(ret == true);
1796 : :
1797 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
1798 : 4 : }
1799 : :
1800 : : static void
1801 : 4 : test_identify_ctrlr(void)
1802 : : {
1803 : 4 : struct spdk_nvmf_tgt tgt = {};
1804 : 4 : struct spdk_nvmf_subsystem subsystem = {
1805 : : .subtype = SPDK_NVMF_SUBTYPE_NVME,
1806 : : .tgt = &tgt,
1807 : : };
1808 : 4 : struct spdk_nvmf_transport_ops tops = {};
1809 : 4 : struct spdk_nvmf_transport transport = {
1810 : : .ops = &tops,
1811 : 1 : .opts = {
1812 : : .in_capsule_data_size = 4096,
1813 : : },
1814 : : };
1815 : 4 : struct spdk_nvmf_qpair admin_qpair = { .transport = &transport};
1816 : 4 : struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair };
1817 : 4 : struct spdk_nvme_ctrlr_data cdata = {};
1818 : : uint32_t expected_ioccsz;
1819 : :
1820 : 4 : nvmf_ctrlr_cdata_init(&transport, &subsystem, &ctrlr.cdata);
1821 : :
1822 : : /* Check ioccsz, TCP transport */
1823 : 4 : tops.type = SPDK_NVME_TRANSPORT_TCP;
1824 : 4 : expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16;
1825 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1826 : 4 : CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz);
1827 : :
1828 : : /* Check ioccsz, RDMA transport */
1829 : 4 : tops.type = SPDK_NVME_TRANSPORT_RDMA;
1830 : 4 : expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16;
1831 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1832 : 4 : CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz);
1833 : :
1834 : : /* Check ioccsz, TCP transport with dif_insert_or_strip */
1835 : 4 : tops.type = SPDK_NVME_TRANSPORT_TCP;
1836 : 4 : ctrlr.dif_insert_or_strip = true;
1837 : 4 : expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16;
1838 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1839 : 4 : CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz);
1840 : 4 : }
1841 : :
1842 : : static void
1843 : 4 : test_identify_ctrlr_iocs_specific(void)
1844 : : {
1845 : 4 : struct spdk_nvmf_subsystem subsystem = { .max_zone_append_size_kib = 0 };
1846 : 4 : struct spdk_nvmf_registers vcprop = { .cap.bits.mpsmin = 0 };
1847 : 4 : struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .vcprop = vcprop };
1848 : 4 : struct spdk_nvme_cmd cmd = {};
1849 : 4 : struct spdk_nvme_cpl rsp = {};
1850 : 4 : struct spdk_nvme_zns_ctrlr_data ctrlr_data = {};
1851 : 4 : struct spdk_nvme_nvm_ctrlr_data cdata_nvm = {};
1852 : :
1853 : 4 : cmd.cdw11_bits.identify.csi = SPDK_NVME_CSI_ZNS;
1854 : :
1855 : : /* ZNS max_zone_append_size_kib no limit */
1856 [ - + ]: 4 : memset(&ctrlr_data, 0xFF, sizeof(ctrlr_data));
1857 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1858 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1859 : : &ctrlr_data, sizeof(ctrlr_data)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1860 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1861 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1862 : 4 : CU_ASSERT(ctrlr_data.zasl == 0);
1863 : 4 : CU_ASSERT(spdk_mem_all_zero(&ctrlr_data, sizeof(ctrlr_data)));
1864 : :
1865 : : /* ZNS max_zone_append_size_kib = 4096 */
1866 [ - + ]: 4 : memset(&ctrlr_data, 0xFF, sizeof(ctrlr_data));
1867 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1868 : 4 : subsystem.max_zone_append_size_kib = 4096;
1869 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1870 : : &ctrlr_data, sizeof(ctrlr_data)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1871 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1872 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1873 : 4 : CU_ASSERT(ctrlr_data.zasl == 0);
1874 : 4 : CU_ASSERT(spdk_mem_all_zero(&ctrlr_data, sizeof(ctrlr_data)));
1875 : :
1876 : : /* ZNS max_zone_append_size_kib = 60000 */
1877 [ - + ]: 4 : memset(&ctrlr_data, 0xFF, sizeof(ctrlr_data));
1878 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1879 : 4 : subsystem.max_zone_append_size_kib = 60000;
1880 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1881 : : &ctrlr_data, sizeof(ctrlr_data)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1882 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1883 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1884 : 4 : CU_ASSERT(ctrlr_data.zasl == 3);
1885 : 4 : ctrlr_data.zasl = 0;
1886 : 4 : CU_ASSERT(spdk_mem_all_zero(&ctrlr_data, sizeof(ctrlr_data)));
1887 : :
1888 : : /* ZNS max_zone_append_size_kib = 60000; mpsmin = 2 */
1889 [ - + ]: 4 : memset(&ctrlr_data, 0xFF, sizeof(ctrlr_data));
1890 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1891 : 4 : ctrlr.vcprop.cap.bits.mpsmin = 2;
1892 : 4 : subsystem.max_zone_append_size_kib = 60000;
1893 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1894 : : &ctrlr_data, sizeof(ctrlr_data)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1895 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1896 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1897 : 4 : CU_ASSERT(ctrlr_data.zasl == 1);
1898 : 4 : ctrlr_data.zasl = 0;
1899 : 4 : CU_ASSERT(spdk_mem_all_zero(&ctrlr_data, sizeof(ctrlr_data)));
1900 : 4 : ctrlr.vcprop.cap.bits.mpsmin = 0;
1901 : :
1902 : 4 : cmd.cdw11_bits.identify.csi = SPDK_NVME_CSI_NVM;
1903 : :
1904 : : /* NVM max_discard_size_kib = 1024;
1905 : : * max_write_zeroes_size_kib = 1024;
1906 : : * mpsmin = 0;
1907 : : */
1908 [ - + ]: 4 : memset(&cdata_nvm, 0xFF, sizeof(cdata_nvm));
1909 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1910 : 4 : subsystem.max_discard_size_kib = (uint64_t)1024;
1911 : 4 : subsystem.max_write_zeroes_size_kib = (uint64_t)1024;
1912 : 4 : CU_ASSERT(spdk_nvmf_ctrlr_identify_iocs_specific(&ctrlr, &cmd, &rsp,
1913 : : &cdata_nvm, sizeof(cdata_nvm)) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1914 : 4 : CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC);
1915 : 4 : CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS);
1916 : 4 : CU_ASSERT(cdata_nvm.wzsl == 8);
1917 : 4 : CU_ASSERT(cdata_nvm.dmrsl == 2048);
1918 : 4 : CU_ASSERT(cdata_nvm.dmrl == 1);
1919 : 4 : }
1920 : :
1921 : : static int
1922 : 4 : custom_admin_cmd_hdlr(struct spdk_nvmf_request *req)
1923 : : {
1924 : 4 : req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
1925 : :
1926 : 4 : return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;
1927 : : };
1928 : :
1929 : : static void
1930 : 4 : test_custom_admin_cmd(void)
1931 : : {
1932 : 3 : struct spdk_nvmf_subsystem subsystem;
1933 : 3 : struct spdk_nvmf_qpair qpair;
1934 : 3 : struct spdk_nvmf_ctrlr ctrlr;
1935 : 3 : struct spdk_nvmf_request req;
1936 : 3 : struct spdk_nvmf_ns *ns_ptrs[1];
1937 : 3 : struct spdk_nvmf_ns ns;
1938 : 3 : union nvmf_h2c_msg cmd;
1939 : 3 : union nvmf_c2h_msg rsp;
1940 : 3 : struct spdk_bdev bdev;
1941 : 3 : uint8_t buf[4096];
1942 : : int rc;
1943 : :
1944 [ - + ]: 4 : memset(&subsystem, 0, sizeof(subsystem));
1945 : 4 : ns_ptrs[0] = &ns;
1946 : 4 : subsystem.ns = ns_ptrs;
1947 : 4 : subsystem.max_nsid = 1;
1948 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
1949 : :
1950 [ - + ]: 4 : memset(&ns, 0, sizeof(ns));
1951 : 4 : ns.opts.nsid = 1;
1952 : 4 : ns.bdev = &bdev;
1953 : :
1954 [ - + ]: 4 : memset(&qpair, 0, sizeof(qpair));
1955 : 4 : qpair.ctrlr = &ctrlr;
1956 : :
1957 [ - + ]: 4 : memset(&ctrlr, 0, sizeof(ctrlr));
1958 : 4 : ctrlr.subsys = &subsystem;
1959 : 4 : ctrlr.vcprop.cc.bits.en = 1;
1960 : 4 : ctrlr.thread = spdk_get_thread();
1961 : :
1962 [ - + ]: 4 : memset(&req, 0, sizeof(req));
1963 : 4 : req.qpair = &qpair;
1964 : 4 : req.cmd = &cmd;
1965 : 4 : req.rsp = &rsp;
1966 : 4 : req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
1967 : 4 : req.length = sizeof(buf);
1968 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &buf, req.length);
1969 : :
1970 [ - + ]: 4 : memset(&cmd, 0, sizeof(cmd));
1971 : 4 : cmd.nvme_cmd.opc = 0xc1;
1972 : 4 : cmd.nvme_cmd.nsid = 0;
1973 [ - + ]: 4 : memset(&rsp, 0, sizeof(rsp));
1974 : :
1975 : 4 : spdk_nvmf_set_custom_admin_cmd_hdlr(cmd.nvme_cmd.opc, custom_admin_cmd_hdlr);
1976 : :
1977 : : /* Ensure that our hdlr is being called */
1978 : 4 : rc = nvmf_ctrlr_process_admin_cmd(&req);
1979 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
1980 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1981 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
1982 : 4 : }
1983 : :
1984 : : static void
1985 : 4 : test_fused_compare_and_write(void)
1986 : : {
1987 : 4 : struct spdk_nvmf_request req = {};
1988 : 4 : struct spdk_nvmf_qpair qpair = {};
1989 : 4 : struct spdk_nvme_cmd cmd = {};
1990 : 4 : union nvmf_c2h_msg rsp = {};
1991 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
1992 : 4 : struct spdk_nvmf_subsystem subsystem = {};
1993 : 4 : struct spdk_nvmf_ns ns = {};
1994 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
1995 : 3 : enum spdk_nvme_ana_state ana_state[1];
1996 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
1997 : 4 : struct spdk_bdev bdev = {};
1998 : :
1999 : 4 : struct spdk_nvmf_poll_group group = {};
2000 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2001 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
2002 : 4 : struct spdk_io_channel io_ch = {};
2003 : :
2004 : 4 : ns.bdev = &bdev;
2005 : 4 : ns.anagrpid = 1;
2006 : :
2007 : 4 : subsystem.id = 0;
2008 : 4 : subsystem.max_nsid = 1;
2009 : 4 : subsys_ns[0] = &ns;
2010 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
2011 : :
2012 : 4 : listener.ana_state[0] = SPDK_NVME_ANA_OPTIMIZED_STATE;
2013 : :
2014 : : /* Enable controller */
2015 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2016 : 4 : ctrlr.subsys = (struct spdk_nvmf_subsystem *)&subsystem;
2017 : 4 : ctrlr.listener = &listener;
2018 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
2019 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
2020 : :
2021 : 4 : group.num_sgroups = 1;
2022 : 4 : sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2023 : 4 : sgroups.num_ns = 1;
2024 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2025 : 4 : ns_info.channel = &io_ch;
2026 : 4 : sgroups.ns_info = &ns_info;
2027 : 4 : TAILQ_INIT(&sgroups.queued);
2028 : 4 : group.sgroups = &sgroups;
2029 : 4 : TAILQ_INIT(&qpair.outstanding);
2030 : :
2031 : 4 : qpair.ctrlr = &ctrlr;
2032 : 4 : qpair.group = &group;
2033 : 4 : qpair.qid = 1;
2034 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2035 : :
2036 : 4 : cmd.nsid = 1;
2037 : :
2038 : 4 : req.qpair = &qpair;
2039 : 4 : req.cmd = (union nvmf_h2c_msg *)&cmd;
2040 : 4 : req.rsp = &rsp;
2041 : :
2042 : : /* SUCCESS/SUCCESS */
2043 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST;
2044 : 4 : cmd.opc = SPDK_NVME_OPC_COMPARE;
2045 : :
2046 : 4 : spdk_nvmf_request_exec(&req);
2047 : 4 : CU_ASSERT(qpair.first_fused_req != NULL);
2048 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
2049 : :
2050 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND;
2051 : 4 : cmd.opc = SPDK_NVME_OPC_WRITE;
2052 : :
2053 : 4 : spdk_nvmf_request_exec(&req);
2054 : 4 : CU_ASSERT(qpair.first_fused_req == NULL);
2055 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
2056 : :
2057 : : /* Wrong sequence */
2058 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND;
2059 : 4 : cmd.opc = SPDK_NVME_OPC_WRITE;
2060 : :
2061 : 4 : spdk_nvmf_request_exec(&req);
2062 : 4 : CU_ASSERT(!nvme_status_success(&rsp.nvme_cpl.status));
2063 : 4 : CU_ASSERT(qpair.first_fused_req == NULL);
2064 : :
2065 : : /* Write as FUSE_FIRST (Wrong op code) */
2066 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST;
2067 : 4 : cmd.opc = SPDK_NVME_OPC_WRITE;
2068 : :
2069 : 4 : spdk_nvmf_request_exec(&req);
2070 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE);
2071 : 4 : CU_ASSERT(qpair.first_fused_req == NULL);
2072 : :
2073 : : /* Compare as FUSE_SECOND (Wrong op code) */
2074 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST;
2075 : 4 : cmd.opc = SPDK_NVME_OPC_COMPARE;
2076 : :
2077 : 4 : spdk_nvmf_request_exec(&req);
2078 : 4 : CU_ASSERT(qpair.first_fused_req != NULL);
2079 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
2080 : :
2081 : 4 : cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND;
2082 : 4 : cmd.opc = SPDK_NVME_OPC_COMPARE;
2083 : :
2084 : 4 : spdk_nvmf_request_exec(&req);
2085 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE);
2086 : 4 : CU_ASSERT(qpair.first_fused_req == NULL);
2087 : :
2088 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
2089 : 4 : }
2090 : :
2091 : : static void
2092 : 4 : test_multi_async_event_reqs(void)
2093 : : {
2094 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2095 : 4 : struct spdk_nvmf_qpair qpair = {};
2096 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2097 : 4 : struct spdk_nvmf_request req[5] = {};
2098 : 4 : struct spdk_nvmf_ns *ns_ptrs[1] = {};
2099 : 4 : struct spdk_nvmf_ns ns = {};
2100 : 4 : union nvmf_h2c_msg cmd[5] = {};
2101 : 4 : union nvmf_c2h_msg rsp[5] = {};
2102 : :
2103 : 4 : struct spdk_nvmf_poll_group group = {};
2104 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2105 : :
2106 : : int i;
2107 : :
2108 : 4 : ns_ptrs[0] = &ns;
2109 : 4 : subsystem.ns = ns_ptrs;
2110 : 4 : subsystem.max_nsid = 1;
2111 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
2112 : :
2113 : 4 : ns.opts.nsid = 1;
2114 : 4 : group.sgroups = &sgroups;
2115 : :
2116 : 4 : qpair.ctrlr = &ctrlr;
2117 : 4 : qpair.group = &group;
2118 : 4 : TAILQ_INIT(&qpair.outstanding);
2119 : :
2120 : 4 : ctrlr.subsys = &subsystem;
2121 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2122 : 4 : ctrlr.thread = spdk_get_thread();
2123 : :
2124 [ + + ]: 24 : for (i = 0; i < 5; i++) {
2125 : 20 : cmd[i].nvme_cmd.opc = SPDK_NVME_OPC_ASYNC_EVENT_REQUEST;
2126 : 20 : cmd[i].nvme_cmd.nsid = 1;
2127 : 20 : cmd[i].nvme_cmd.cid = i;
2128 : :
2129 : 20 : req[i].qpair = &qpair;
2130 : 20 : req[i].cmd = &cmd[i];
2131 : 20 : req[i].rsp = &rsp[i];
2132 : 20 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req[i], link);
2133 : 5 : }
2134 : :
2135 : : /* Target can store SPDK_NVMF_MAX_ASYNC_EVENTS reqs */
2136 : 4 : sgroups.mgmt_io_outstanding = SPDK_NVMF_MAX_ASYNC_EVENTS;
2137 [ + + ]: 20 : for (i = 0; i < SPDK_NVMF_MAX_ASYNC_EVENTS; i++) {
2138 : 16 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[i]) == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
2139 : 16 : CU_ASSERT(ctrlr.nr_aer_reqs == i + 1);
2140 : 4 : }
2141 : 4 : CU_ASSERT(sgroups.mgmt_io_outstanding == 0);
2142 : :
2143 : : /* Exceeding the SPDK_NVMF_MAX_ASYNC_EVENTS reports error */
2144 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[4]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
2145 : 4 : CU_ASSERT(ctrlr.nr_aer_reqs == SPDK_NVMF_MAX_ASYNC_EVENTS);
2146 : 4 : CU_ASSERT(rsp[4].nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
2147 : 4 : CU_ASSERT(rsp[4].nvme_cpl.status.sc == SPDK_NVME_SC_ASYNC_EVENT_REQUEST_LIMIT_EXCEEDED);
2148 : :
2149 : : /* Test if the aer_reqs keep continuous when abort a req in the middle */
2150 : 4 : CU_ASSERT(nvmf_qpair_abort_aer(&qpair, 2) == true);
2151 : 4 : CU_ASSERT(ctrlr.aer_req[0] == &req[0]);
2152 : 4 : CU_ASSERT(ctrlr.aer_req[1] == &req[1]);
2153 : 4 : CU_ASSERT(ctrlr.aer_req[2] == &req[3]);
2154 : :
2155 : 4 : CU_ASSERT(nvmf_qpair_abort_aer(&qpair, 3) == true);
2156 : 4 : CU_ASSERT(ctrlr.aer_req[0] == &req[0]);
2157 : 4 : CU_ASSERT(ctrlr.aer_req[1] == &req[1]);
2158 : 4 : CU_ASSERT(ctrlr.aer_req[2] == NULL);
2159 : 4 : CU_ASSERT(ctrlr.nr_aer_reqs == 2);
2160 : :
2161 [ + + ]: 4 : TAILQ_REMOVE(&qpair.outstanding, &req[0], link);
2162 [ + + ]: 4 : TAILQ_REMOVE(&qpair.outstanding, &req[1], link);
2163 : 4 : }
2164 : :
2165 : : static void
2166 : 4 : test_get_ana_log_page_one_ns_per_anagrp(void)
2167 : : {
2168 : : #define UT_ANA_DESC_MAX_SIZE (sizeof(struct spdk_nvme_ana_group_descriptor) + sizeof(uint32_t))
2169 : : #define UT_ANA_LOG_PAGE_MAX_SIZE (sizeof(struct spdk_nvme_ana_page) + 3 * UT_ANA_DESC_MAX_SIZE)
2170 : : #define UT_ANA_DESC_SIZE(rgo) (sizeof(struct spdk_nvme_ana_group_descriptor) + (rgo ? 0 : sizeof(uint32_t)))
2171 : : #define UT_ANA_LOG_PAGE_SIZE(rgo) (sizeof(struct spdk_nvme_ana_page) + 3 * UT_ANA_DESC_SIZE(rgo))
2172 : 3 : uint32_t ana_group[3];
2173 : 4 : struct spdk_nvmf_subsystem subsystem = { .ana_group = ana_group };
2174 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2175 : 3 : enum spdk_nvme_ana_state ana_state[3];
2176 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
2177 : 3 : struct spdk_nvmf_ns ns[3];
2178 : 4 : struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], &ns[1], &ns[2]};
2179 : : uint64_t offset;
2180 : : uint32_t length;
2181 : : int i;
2182 : 4 : char expected_page[UT_ANA_LOG_PAGE_MAX_SIZE] = {0};
2183 : 4 : char actual_page[UT_ANA_LOG_PAGE_MAX_SIZE] = {0};
2184 : 3 : struct iovec iov, iovs[2];
2185 : : struct spdk_nvme_ana_page *ana_hdr;
2186 : 3 : char _ana_desc[UT_ANA_DESC_MAX_SIZE];
2187 : : struct spdk_nvme_ana_group_descriptor *ana_desc;
2188 : : uint32_t rgo;
2189 : :
2190 : 4 : subsystem.ns = ns_arr;
2191 : 4 : subsystem.max_nsid = 3;
2192 [ + + ]: 16 : for (i = 0; i < 3; i++) {
2193 : 12 : subsystem.ana_group[i] = 1;
2194 : 3 : }
2195 : 4 : ctrlr.subsys = &subsystem;
2196 : 4 : ctrlr.listener = &listener;
2197 : :
2198 [ + + ]: 16 : for (i = 0; i < 3; i++) {
2199 : 12 : listener.ana_state[i] = SPDK_NVME_ANA_OPTIMIZED_STATE;
2200 : 3 : }
2201 : :
2202 [ + + ]: 16 : for (i = 0; i < 3; i++) {
2203 : 12 : ns_arr[i]->nsid = i + 1;
2204 : 12 : ns_arr[i]->anagrpid = i + 1;
2205 : 3 : }
2206 : :
2207 [ + + ]: 12 : for (rgo = 0; rgo <= 1; rgo++) {
2208 : 8 : memset(expected_page, 0, sizeof(expected_page));
2209 : 8 : memset(actual_page, 0, sizeof(actual_page));
2210 : :
2211 : : /* create expected page */
2212 : 8 : ana_hdr = (void *)&expected_page[0];
2213 : 8 : ana_hdr->num_ana_group_desc = 3;
2214 : 8 : ana_hdr->change_count = 0;
2215 : :
2216 : : /* descriptor may be unaligned. So create data and then copy it to the location. */
2217 : 8 : ana_desc = (void *)_ana_desc;
2218 : 8 : offset = sizeof(struct spdk_nvme_ana_page);
2219 : :
2220 [ + + ]: 32 : for (i = 0; i < 3; i++) {
2221 [ - + ]: 24 : memset(ana_desc, 0, UT_ANA_DESC_MAX_SIZE);
2222 : 24 : ana_desc->ana_group_id = ns_arr[i]->nsid;
2223 : 24 : ana_desc->num_of_nsid = rgo ? 0 : 1;
2224 : 24 : ana_desc->change_count = 0;
2225 : 24 : ana_desc->ana_state = ctrlr.listener->ana_state[i];
2226 [ + + ]: 24 : if (!rgo) {
2227 : 12 : ana_desc->nsid[0] = ns_arr[i]->nsid;
2228 : 3 : }
2229 [ + + - + : 24 : memcpy(&expected_page[offset], ana_desc, UT_ANA_DESC_SIZE(rgo));
- + ]
2230 [ + + ]: 24 : offset += UT_ANA_DESC_SIZE(rgo);
2231 : 6 : }
2232 : :
2233 : : /* read entire actual log page */
2234 : 8 : offset = 0;
2235 [ + + ]: 72 : while (offset < UT_ANA_LOG_PAGE_MAX_SIZE) {
2236 [ + + ]: 64 : length = spdk_min(16, UT_ANA_LOG_PAGE_MAX_SIZE - offset);
2237 : 64 : iov.iov_base = &actual_page[offset];
2238 : 64 : iov.iov_len = length;
2239 : 64 : nvmf_get_ana_log_page(&ctrlr, &iov, 1, offset, length, 0, rgo);
2240 : 64 : offset += length;
2241 : : }
2242 : :
2243 : : /* compare expected page and actual page */
2244 : 8 : CU_ASSERT(memcmp(expected_page, actual_page, UT_ANA_LOG_PAGE_MAX_SIZE) == 0);
2245 : :
2246 : 8 : memset(&actual_page[0], 0, UT_ANA_LOG_PAGE_MAX_SIZE);
2247 : 8 : offset = 0;
2248 : 8 : iovs[0].iov_base = &actual_page[offset];
2249 : 8 : iovs[0].iov_len = UT_ANA_LOG_PAGE_MAX_SIZE - UT_ANA_DESC_MAX_SIZE + 4;
2250 : 8 : offset += UT_ANA_LOG_PAGE_MAX_SIZE - UT_ANA_DESC_MAX_SIZE + 4;
2251 : 8 : iovs[1].iov_base = &actual_page[offset];
2252 : 8 : iovs[1].iov_len = UT_ANA_LOG_PAGE_MAX_SIZE - offset;
2253 : 8 : nvmf_get_ana_log_page(&ctrlr, &iovs[0], 2, 0, UT_ANA_LOG_PAGE_MAX_SIZE, 0, rgo);
2254 : :
2255 : 8 : CU_ASSERT(memcmp(expected_page, actual_page, UT_ANA_LOG_PAGE_MAX_SIZE) == 0);
2256 : 2 : }
2257 : :
2258 : : #undef UT_ANA_DESC_SIZE
2259 : : #undef UT_ANA_LOG_PAGE_SIZE
2260 : : #undef UT_ANA_DESC_MAX_SIZE
2261 : : #undef UT_ANA_LOG_PAGE_MAX_SIZE
2262 : 4 : }
2263 : :
2264 : : static void
2265 : 4 : test_get_ana_log_page_multi_ns_per_anagrp(void)
2266 : : {
2267 : : #define UT_ANA_LOG_PAGE_SIZE(rgo) (sizeof(struct spdk_nvme_ana_page) + \
2268 : : sizeof(struct spdk_nvme_ana_group_descriptor) * 2 + \
2269 : : (rgo ? 0 : (sizeof(uint32_t) * 5)))
2270 : : #define UT_ANA_LOG_PAGE_MAX_SIZE (sizeof(struct spdk_nvme_ana_page) + \
2271 : : sizeof(struct spdk_nvme_ana_group_descriptor) * 2 + \
2272 : : sizeof(uint32_t) * 5)
2273 : 3 : struct spdk_nvmf_ns ns[5];
2274 : 4 : struct spdk_nvmf_ns *ns_arr[5] = {&ns[0], &ns[1], &ns[2], &ns[3], &ns[4]};
2275 : 4 : uint32_t ana_group[5] = {0};
2276 : 4 : struct spdk_nvmf_subsystem subsystem = { .ns = ns_arr, .ana_group = ana_group, };
2277 : 3 : enum spdk_nvme_ana_state ana_state[5];
2278 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state, };
2279 : 4 : struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .listener = &listener, };
2280 : 4 : char expected_page[UT_ANA_LOG_PAGE_MAX_SIZE] = {0};
2281 : 4 : char actual_page[UT_ANA_LOG_PAGE_MAX_SIZE] = {0};
2282 : 3 : struct iovec iov, iovs[2];
2283 : : struct spdk_nvme_ana_page *ana_hdr;
2284 : 3 : char _ana_desc[UT_ANA_LOG_PAGE_MAX_SIZE];
2285 : : struct spdk_nvme_ana_group_descriptor *ana_desc;
2286 : : uint64_t offset;
2287 : : uint32_t length;
2288 : : int i;
2289 : : uint32_t rgo;
2290 : :
2291 : 4 : subsystem.max_nsid = 5;
2292 : 4 : subsystem.ana_group[1] = 3;
2293 : 4 : subsystem.ana_group[2] = 2;
2294 [ + + ]: 24 : for (i = 0; i < 5; i++) {
2295 : 20 : listener.ana_state[i] = SPDK_NVME_ANA_OPTIMIZED_STATE;
2296 : 5 : }
2297 : :
2298 [ + + ]: 24 : for (i = 0; i < 5; i++) {
2299 : 20 : ns_arr[i]->nsid = i + 1;
2300 : 5 : }
2301 : 4 : ns_arr[0]->anagrpid = 2;
2302 : 4 : ns_arr[1]->anagrpid = 3;
2303 : 4 : ns_arr[2]->anagrpid = 2;
2304 : 4 : ns_arr[3]->anagrpid = 3;
2305 : 4 : ns_arr[4]->anagrpid = 2;
2306 : :
2307 [ + + ]: 12 : for (rgo = 0; rgo <= 1; rgo++) {
2308 : 8 : memset(expected_page, 0, sizeof(expected_page));
2309 : 8 : memset(actual_page, 0, sizeof(actual_page));
2310 : :
2311 : : /* create expected page */
2312 : 8 : ana_hdr = (void *)&expected_page[0];
2313 : 8 : ana_hdr->num_ana_group_desc = 2;
2314 : 8 : ana_hdr->change_count = 0;
2315 : :
2316 : : /* descriptor may be unaligned. So create data and then copy it to the location. */
2317 : 8 : ana_desc = (void *)_ana_desc;
2318 : 8 : offset = sizeof(struct spdk_nvme_ana_page);
2319 : :
2320 : 8 : memset(_ana_desc, 0, sizeof(_ana_desc));
2321 : 8 : ana_desc->ana_group_id = 2;
2322 [ + + ]: 8 : ana_desc->num_of_nsid = rgo ? 0 : 3;
2323 : 8 : ana_desc->change_count = 0;
2324 : 8 : ana_desc->ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE;
2325 [ + + ]: 8 : if (!rgo) {
2326 : 4 : ana_desc->nsid[0] = 1;
2327 : 4 : ana_desc->nsid[1] = 3;
2328 : 4 : ana_desc->nsid[2] = 5;
2329 : 1 : }
2330 [ + + - + : 10 : memcpy(&expected_page[offset], ana_desc, sizeof(struct spdk_nvme_ana_group_descriptor) +
- + ]
2331 : 2 : (rgo ? 0 : (sizeof(uint32_t) * 3)));
2332 [ + + ]: 8 : offset += sizeof(struct spdk_nvme_ana_group_descriptor) + (rgo ? 0 : (sizeof(uint32_t) * 3));
2333 : :
2334 : 8 : memset(_ana_desc, 0, sizeof(_ana_desc));
2335 : 8 : ana_desc->ana_group_id = 3;
2336 [ + + ]: 8 : ana_desc->num_of_nsid = rgo ? 0 : 2;
2337 : 8 : ana_desc->change_count = 0;
2338 : 8 : ana_desc->ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE;
2339 [ + + ]: 8 : if (!rgo) {
2340 : 4 : ana_desc->nsid[0] = 2;
2341 : 4 : ana_desc->nsid[1] = 4;
2342 : 1 : }
2343 [ + + - + : 10 : memcpy(&expected_page[offset], ana_desc, sizeof(struct spdk_nvme_ana_group_descriptor) +
- + ]
2344 : 2 : (rgo ? 0 : (sizeof(uint32_t) * 2)));
2345 : :
2346 : : /* read entire actual log page, and compare expected page and actual page. */
2347 : 8 : offset = 0;
2348 [ + + ]: 64 : while (offset < UT_ANA_LOG_PAGE_MAX_SIZE) {
2349 [ + + ]: 56 : length = spdk_min(16, UT_ANA_LOG_PAGE_MAX_SIZE - offset);
2350 : 56 : iov.iov_base = &actual_page[offset];
2351 : 56 : iov.iov_len = length;
2352 : 56 : nvmf_get_ana_log_page(&ctrlr, &iov, 1, offset, length, 0, rgo);
2353 : 56 : offset += length;
2354 : : }
2355 : :
2356 : 8 : CU_ASSERT(memcmp(expected_page, actual_page, UT_ANA_LOG_PAGE_MAX_SIZE) == 0);
2357 : :
2358 : 8 : memset(&actual_page[0], 0, UT_ANA_LOG_PAGE_MAX_SIZE);
2359 : 8 : offset = 0;
2360 : 8 : iovs[0].iov_base = &actual_page[offset];
2361 : 8 : iovs[0].iov_len = UT_ANA_LOG_PAGE_MAX_SIZE - sizeof(uint32_t) * 5;
2362 : 8 : offset += UT_ANA_LOG_PAGE_MAX_SIZE - sizeof(uint32_t) * 5;
2363 : 8 : iovs[1].iov_base = &actual_page[offset];
2364 : 8 : iovs[1].iov_len = sizeof(uint32_t) * 5;
2365 : 8 : nvmf_get_ana_log_page(&ctrlr, &iovs[0], 2, 0, UT_ANA_LOG_PAGE_MAX_SIZE, 0, rgo);
2366 : :
2367 : 8 : CU_ASSERT(memcmp(expected_page, actual_page, UT_ANA_LOG_PAGE_MAX_SIZE) == 0);
2368 : 2 : }
2369 : :
2370 : : #undef UT_ANA_LOG_PAGE_SIZE
2371 : : #undef UT_ANA_LOG_PAGE_MAX_SIZE
2372 : 4 : }
2373 : : static void
2374 : 4 : test_multi_async_events(void)
2375 : : {
2376 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2377 : 4 : struct spdk_nvmf_qpair qpair = {};
2378 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2379 : 4 : struct spdk_nvmf_request req[4] = {};
2380 : 4 : struct spdk_nvmf_ns *ns_ptrs[1] = {};
2381 : 4 : struct spdk_nvmf_ns ns = {};
2382 : 4 : union nvmf_h2c_msg cmd[4] = {};
2383 : 4 : union nvmf_c2h_msg rsp[4] = {};
2384 : 4 : union spdk_nvme_async_event_completion event = {};
2385 : 4 : struct spdk_nvmf_poll_group group = {};
2386 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2387 : : int i;
2388 : :
2389 : 4 : ns_ptrs[0] = &ns;
2390 : 4 : subsystem.ns = ns_ptrs;
2391 : 4 : subsystem.max_nsid = 1;
2392 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
2393 : :
2394 : 4 : ns.opts.nsid = 1;
2395 : 4 : group.sgroups = &sgroups;
2396 : :
2397 : 4 : qpair.ctrlr = &ctrlr;
2398 : 4 : qpair.group = &group;
2399 : 4 : TAILQ_INIT(&qpair.outstanding);
2400 : :
2401 : 4 : ctrlr.subsys = &subsystem;
2402 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2403 : 4 : ctrlr.thread = spdk_get_thread();
2404 : 4 : ctrlr.feat.async_event_configuration.bits.ns_attr_notice = 1;
2405 : 4 : ctrlr.feat.async_event_configuration.bits.ana_change_notice = 1;
2406 : 4 : ctrlr.feat.async_event_configuration.bits.discovery_log_change_notice = 1;
2407 : 4 : init_pending_async_events(&ctrlr);
2408 : :
2409 : : /* Target queue pending events when there is no outstanding AER request */
2410 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2411 : 4 : nvmf_ctrlr_async_event_ana_change_notice(&ctrlr);
2412 : 4 : nvmf_ctrlr_async_event_discovery_log_change_notice(&ctrlr);
2413 : :
2414 [ + + ]: 20 : for (i = 0; i < 4; i++) {
2415 : 16 : cmd[i].nvme_cmd.opc = SPDK_NVME_OPC_ASYNC_EVENT_REQUEST;
2416 : 16 : cmd[i].nvme_cmd.nsid = 1;
2417 : 16 : cmd[i].nvme_cmd.cid = i;
2418 : :
2419 : 16 : req[i].qpair = &qpair;
2420 : 16 : req[i].cmd = &cmd[i];
2421 : 16 : req[i].rsp = &rsp[i];
2422 : :
2423 : 16 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req[i], link);
2424 : :
2425 : 16 : sgroups.mgmt_io_outstanding = 1;
2426 [ + + ]: 16 : if (i < 3) {
2427 : 12 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[i]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
2428 : 12 : CU_ASSERT(sgroups.mgmt_io_outstanding == 0);
2429 : 12 : CU_ASSERT(ctrlr.nr_aer_reqs == 0);
2430 : 3 : } else {
2431 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[i]) == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
2432 : 4 : CU_ASSERT(sgroups.mgmt_io_outstanding == 0);
2433 : 4 : CU_ASSERT(ctrlr.nr_aer_reqs == 1);
2434 : : }
2435 : 4 : }
2436 : :
2437 : 4 : event.raw = rsp[0].nvme_cpl.cdw0;
2438 : 4 : CU_ASSERT(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED);
2439 : 4 : event.raw = rsp[1].nvme_cpl.cdw0;
2440 : 4 : CU_ASSERT(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_ANA_CHANGE);
2441 : 4 : event.raw = rsp[2].nvme_cpl.cdw0;
2442 : 4 : CU_ASSERT(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_DISCOVERY_LOG_CHANGE);
2443 : :
2444 : 4 : cleanup_pending_async_events(&ctrlr);
2445 : 4 : }
2446 : :
2447 : : static void
2448 : 4 : test_rae(void)
2449 : : {
2450 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2451 : 4 : struct spdk_nvmf_qpair qpair = {};
2452 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2453 : 4 : struct spdk_nvmf_request req[3] = {};
2454 : 4 : struct spdk_nvmf_ns *ns_ptrs[1] = {};
2455 : 4 : struct spdk_nvmf_ns ns = {};
2456 : 4 : union nvmf_h2c_msg cmd[3] = {};
2457 : 4 : union nvmf_c2h_msg rsp[3] = {};
2458 : 4 : union spdk_nvme_async_event_completion event = {};
2459 : 4 : struct spdk_nvmf_poll_group group = {};
2460 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2461 : : int i;
2462 : 3 : char data[4096];
2463 : :
2464 : 4 : ns_ptrs[0] = &ns;
2465 : 4 : subsystem.ns = ns_ptrs;
2466 : 4 : subsystem.max_nsid = 1;
2467 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
2468 : :
2469 : 4 : ns.opts.nsid = 1;
2470 : 4 : group.sgroups = &sgroups;
2471 : :
2472 : 4 : qpair.ctrlr = &ctrlr;
2473 : 4 : qpair.group = &group;
2474 : 4 : TAILQ_INIT(&qpair.outstanding);
2475 : :
2476 : 4 : ctrlr.subsys = &subsystem;
2477 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2478 : 4 : ctrlr.thread = spdk_get_thread();
2479 : 4 : ctrlr.feat.async_event_configuration.bits.ns_attr_notice = 1;
2480 : 4 : init_pending_async_events(&ctrlr);
2481 : :
2482 : : /* Target queue pending events when there is no outstanding AER request */
2483 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2484 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2485 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2486 : : /* only one event will be queued before RAE is clear */
2487 : 4 : CU_ASSERT(num_pending_async_events(&ctrlr) == 1);
2488 : :
2489 : 4 : req[0].qpair = &qpair;
2490 : 4 : req[0].cmd = &cmd[0];
2491 : 4 : req[0].rsp = &rsp[0];
2492 : 4 : cmd[0].nvme_cmd.opc = SPDK_NVME_OPC_ASYNC_EVENT_REQUEST;
2493 : 4 : cmd[0].nvme_cmd.nsid = 1;
2494 : 4 : cmd[0].nvme_cmd.cid = 0;
2495 : :
2496 [ + + ]: 12 : for (i = 1; i < 3; i++) {
2497 : 8 : req[i].qpair = &qpair;
2498 : 8 : req[i].cmd = &cmd[i];
2499 : 8 : req[i].rsp = &rsp[i];
2500 : 8 : req[i].length = sizeof(data);
2501 : 8 : SPDK_IOV_ONE(req[i].iov, &req[i].iovcnt, &data, req[i].length);
2502 : :
2503 : 8 : cmd[i].nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
2504 : 8 : cmd[i].nvme_cmd.cdw10_bits.get_log_page.lid =
2505 : : SPDK_NVME_LOG_CHANGED_NS_LIST;
2506 : 8 : cmd[i].nvme_cmd.cdw10_bits.get_log_page.numdl =
2507 : 8 : spdk_nvme_bytes_to_numd(req[i].length);
2508 : 8 : cmd[i].nvme_cmd.cid = i;
2509 : 2 : }
2510 : 4 : cmd[1].nvme_cmd.cdw10_bits.get_log_page.rae = 1;
2511 : 4 : cmd[2].nvme_cmd.cdw10_bits.get_log_page.rae = 0;
2512 : :
2513 : : /* consume the pending event */
2514 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req[0], link);
2515 : 4 : CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[0]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
2516 : 4 : event.raw = rsp[0].nvme_cpl.cdw0;
2517 : 4 : CU_ASSERT(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_NS_ATTR_CHANGED);
2518 : 4 : CU_ASSERT(num_pending_async_events(&ctrlr) == 0);
2519 : :
2520 : : /* get log with RAE set */
2521 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req[1]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
2522 : 4 : CU_ASSERT(rsp[1].nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
2523 : 4 : CU_ASSERT(rsp[1].nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
2524 : :
2525 : : /* will not generate new event until RAE is clear */
2526 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2527 : 4 : CU_ASSERT(num_pending_async_events(&ctrlr) == 0);
2528 : :
2529 : : /* get log with RAE clear */
2530 : 4 : CU_ASSERT(nvmf_ctrlr_get_log_page(&req[2]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
2531 : 4 : CU_ASSERT(rsp[2].nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
2532 : 4 : CU_ASSERT(rsp[2].nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
2533 : :
2534 : 4 : nvmf_ctrlr_async_event_ns_notice(&ctrlr);
2535 : 4 : CU_ASSERT(num_pending_async_events(&ctrlr) == 1);
2536 : :
2537 : 4 : cleanup_pending_async_events(&ctrlr);
2538 : 4 : }
2539 : :
2540 : : static void
2541 : 4 : test_nvmf_ctrlr_create_destruct(void)
2542 : : {
2543 : 4 : struct spdk_nvmf_fabric_connect_data connect_data = {};
2544 : 4 : struct spdk_nvmf_poll_group group = {};
2545 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups[2] = {};
2546 : 4 : struct spdk_nvmf_transport transport = {};
2547 : 4 : struct spdk_nvmf_transport_ops tops = {};
2548 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2549 : 4 : struct spdk_nvmf_ns *ns_arr[1] = { NULL };
2550 : 4 : struct spdk_nvmf_request req = {};
2551 : 4 : struct spdk_nvmf_qpair qpair = {};
2552 : 4 : struct spdk_nvmf_ctrlr *ctrlr = NULL;
2553 : 4 : struct spdk_nvmf_tgt tgt = {};
2554 : 4 : union nvmf_h2c_msg cmd = {};
2555 : 4 : union nvmf_c2h_msg rsp = {};
2556 : 4 : const uint8_t hostid[16] = {
2557 : : 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
2558 : : 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
2559 : : };
2560 : 4 : const char subnqn[] = "nqn.2016-06.io.spdk:subsystem1";
2561 : 4 : const char hostnqn[] = "nqn.2016-06.io.spdk:host1";
2562 : :
2563 : 4 : group.thread = spdk_get_thread();
2564 : 4 : transport.ops = &tops;
2565 : 4 : transport.opts.max_aq_depth = 32;
2566 : 4 : transport.opts.max_queue_depth = 64;
2567 : 4 : transport.opts.max_qpairs_per_ctrlr = 3;
2568 : 4 : transport.opts.dif_insert_or_strip = true;
2569 : 4 : transport.tgt = &tgt;
2570 : 4 : qpair.transport = &transport;
2571 : 4 : qpair.group = &group;
2572 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
2573 : 4 : TAILQ_INIT(&qpair.outstanding);
2574 : :
2575 : 4 : memcpy(connect_data.hostid, hostid, sizeof(hostid));
2576 : 4 : connect_data.cntlid = 0xFFFF;
2577 : 4 : snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn);
2578 : 4 : snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn);
2579 : :
2580 : 4 : subsystem.thread = spdk_get_thread();
2581 : 4 : subsystem.id = 1;
2582 : 4 : TAILQ_INIT(&subsystem.ctrlrs);
2583 : 4 : subsystem.tgt = &tgt;
2584 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
2585 : 4 : subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2586 : 4 : snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn);
2587 : 4 : subsystem.ns = ns_arr;
2588 : :
2589 : 4 : group.sgroups = sgroups;
2590 : :
2591 : 4 : cmd.connect_cmd.opcode = SPDK_NVME_OPC_FABRIC;
2592 : 4 : cmd.connect_cmd.cid = 1;
2593 : 4 : cmd.connect_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT;
2594 : 4 : cmd.connect_cmd.recfmt = 0;
2595 : 4 : cmd.connect_cmd.qid = 0;
2596 : 4 : cmd.connect_cmd.sqsize = 31;
2597 : 4 : cmd.connect_cmd.cattr = 0;
2598 : 4 : cmd.connect_cmd.kato = 120000;
2599 : :
2600 : 4 : req.qpair = &qpair;
2601 : 4 : req.xfer = SPDK_NVME_DATA_HOST_TO_CONTROLLER;
2602 : 4 : req.length = sizeof(connect_data);
2603 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &connect_data, req.length);
2604 : 4 : req.cmd = &cmd;
2605 : 4 : req.rsp = &rsp;
2606 : :
2607 : 4 : TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
2608 : 4 : sgroups[subsystem.id].mgmt_io_outstanding++;
2609 : :
2610 : 4 : ctrlr = nvmf_ctrlr_create(&subsystem, &req, &req.cmd->connect_cmd, req.iov[0].iov_base);
2611 : 4 : poll_threads();
2612 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlr != NULL);
2613 : 4 : CU_ASSERT(req.qpair->ctrlr == ctrlr);
2614 : 4 : CU_ASSERT(ctrlr->subsys == &subsystem);
2615 : 4 : CU_ASSERT(ctrlr->thread == req.qpair->group->thread);
2616 [ - + ]: 4 : CU_ASSERT(ctrlr->disconnect_in_progress == false);
2617 : 4 : CU_ASSERT(ctrlr->qpair_mask != NULL);
2618 : 4 : CU_ASSERT(ctrlr->feat.keep_alive_timer.bits.kato == 120000);
2619 : 4 : CU_ASSERT(ctrlr->feat.async_event_configuration.bits.ns_attr_notice == 1);
2620 : 4 : CU_ASSERT(ctrlr->feat.volatile_write_cache.bits.wce == 1);
2621 : 4 : CU_ASSERT(ctrlr->feat.number_of_queues.bits.ncqr == 1);
2622 : 4 : CU_ASSERT(ctrlr->feat.number_of_queues.bits.nsqr == 1);
2623 [ - + ]: 4 : CU_ASSERT(!strncmp((void *)&ctrlr->hostid, hostid, 16));
2624 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.cqr == 1);
2625 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.mqes == 63);
2626 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.ams == 0);
2627 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.to == NVMF_CTRLR_RESET_SHN_TIMEOUT_IN_MS / 500);
2628 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.dstrd == 0);
2629 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.css == SPDK_NVME_CAP_CSS_NVM);
2630 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.mpsmin == 0);
2631 : 4 : CU_ASSERT(ctrlr->vcprop.cap.bits.mpsmax == 0);
2632 : 4 : CU_ASSERT(ctrlr->vcprop.vs.bits.mjr == 1);
2633 : 4 : CU_ASSERT(ctrlr->vcprop.vs.bits.mnr == 3);
2634 : 4 : CU_ASSERT(ctrlr->vcprop.vs.bits.ter == 0);
2635 : 4 : CU_ASSERT(ctrlr->vcprop.cc.raw == 0);
2636 : 4 : CU_ASSERT(ctrlr->vcprop.cc.bits.en == 0);
2637 : 4 : CU_ASSERT(ctrlr->vcprop.csts.raw == 0);
2638 : 4 : CU_ASSERT(ctrlr->vcprop.csts.bits.rdy == 0);
2639 [ - + ]: 4 : CU_ASSERT(ctrlr->dif_insert_or_strip == true);
2640 : :
2641 : 4 : ctrlr->in_destruct = true;
2642 : 4 : nvmf_ctrlr_destruct(ctrlr);
2643 : 4 : poll_threads();
2644 : 4 : CU_ASSERT(TAILQ_EMPTY(&subsystem.ctrlrs));
2645 : 4 : CU_ASSERT(TAILQ_EMPTY(&qpair.outstanding));
2646 : 4 : }
2647 : :
2648 : : static void
2649 : 4 : test_nvmf_ctrlr_use_zcopy(void)
2650 : : {
2651 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2652 : 4 : struct spdk_nvmf_transport transport = {};
2653 : 4 : struct spdk_nvmf_request req = {};
2654 : 4 : struct spdk_nvmf_qpair qpair = {};
2655 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2656 : 4 : union nvmf_h2c_msg cmd = {};
2657 : 4 : struct spdk_nvmf_ns ns = {};
2658 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
2659 : 4 : struct spdk_bdev bdev = {};
2660 : 4 : struct spdk_nvmf_poll_group group = {};
2661 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2662 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
2663 : 4 : struct spdk_io_channel io_ch = {};
2664 : : int opc;
2665 : :
2666 : 4 : subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
2667 : 4 : ns.bdev = &bdev;
2668 : :
2669 : 4 : subsystem.id = 0;
2670 : 4 : subsystem.max_nsid = 1;
2671 : 4 : subsys_ns[0] = &ns;
2672 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
2673 : :
2674 : 4 : ctrlr.subsys = &subsystem;
2675 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
2676 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
2677 : :
2678 : 4 : transport.opts.zcopy = true;
2679 : :
2680 : 4 : qpair.ctrlr = &ctrlr;
2681 : 4 : qpair.group = &group;
2682 : 4 : qpair.qid = 1;
2683 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2684 : 4 : qpair.transport = &transport;
2685 : :
2686 : 4 : group.thread = spdk_get_thread();
2687 : 4 : group.num_sgroups = 1;
2688 : 4 : sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2689 : 4 : sgroups.num_ns = 1;
2690 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2691 : 4 : ns_info.channel = &io_ch;
2692 : 4 : sgroups.ns_info = &ns_info;
2693 : 4 : TAILQ_INIT(&sgroups.queued);
2694 : 4 : group.sgroups = &sgroups;
2695 : 4 : TAILQ_INIT(&qpair.outstanding);
2696 : :
2697 : 4 : req.qpair = &qpair;
2698 : 4 : req.cmd = &cmd;
2699 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2700 : :
2701 : : /* Admin queue */
2702 : 4 : qpair.qid = 0;
2703 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2704 : 4 : qpair.qid = 1;
2705 : :
2706 : : /* Invalid Opcodes */
2707 [ + + ]: 1028 : for (opc = 0; opc <= 255; opc++) {
2708 : 1024 : cmd.nvme_cmd.opc = (enum spdk_nvme_nvm_opcode) opc;
2709 [ + + + + ]: 1024 : if ((cmd.nvme_cmd.opc != SPDK_NVME_OPC_READ) &&
2710 [ + + ]: 1020 : (cmd.nvme_cmd.opc != SPDK_NVME_OPC_WRITE)) {
2711 : 1016 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2712 : 254 : }
2713 : 256 : }
2714 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE;
2715 : :
2716 : : /* Fused WRITE */
2717 : 4 : cmd.nvme_cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND;
2718 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2719 : 4 : cmd.nvme_cmd.fuse = SPDK_NVME_CMD_FUSE_NONE;
2720 : :
2721 : : /* Non bdev */
2722 : 4 : cmd.nvme_cmd.nsid = 4;
2723 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2724 : 4 : cmd.nvme_cmd.nsid = 1;
2725 : :
2726 : : /* ZCOPY Not supported */
2727 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2728 : 4 : ns.zcopy = true;
2729 : :
2730 : : /* ZCOPY disabled on transport level */
2731 : 4 : transport.opts.zcopy = false;
2732 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req) == false);
2733 : 4 : transport.opts.zcopy = true;
2734 : :
2735 : : /* Success */
2736 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2737 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2738 : :
2739 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
2740 : 4 : }
2741 : :
2742 : : static void
2743 : 8 : qpair_state_change_done(void *cb_arg, int status)
2744 : : {
2745 : 8 : }
2746 : :
2747 : : static void
2748 : 4 : test_spdk_nvmf_request_zcopy_start(void)
2749 : : {
2750 : 4 : struct spdk_nvmf_request req = {};
2751 : 4 : struct spdk_nvmf_qpair qpair = {};
2752 : 4 : struct spdk_nvmf_transport transport = {};
2753 : 4 : struct spdk_nvme_cmd cmd = {};
2754 : 4 : union nvmf_c2h_msg rsp = {};
2755 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2756 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2757 : 4 : struct spdk_nvmf_ns ns = {};
2758 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
2759 : 3 : enum spdk_nvme_ana_state ana_state[1];
2760 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
2761 : 4 : struct spdk_bdev bdev = { .blockcnt = 100, .blocklen = 512};
2762 : :
2763 : 4 : struct spdk_nvmf_poll_group group = {};
2764 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2765 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
2766 : 4 : struct spdk_io_channel io_ch = {};
2767 : :
2768 : 4 : ns.bdev = &bdev;
2769 : 4 : ns.zcopy = true;
2770 : 4 : ns.anagrpid = 1;
2771 : :
2772 : 4 : subsystem.id = 0;
2773 : 4 : subsystem.max_nsid = 1;
2774 : 4 : subsys_ns[0] = &ns;
2775 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
2776 : :
2777 : 4 : listener.ana_state[0] = SPDK_NVME_ANA_OPTIMIZED_STATE;
2778 : :
2779 : : /* Enable controller */
2780 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2781 : 4 : ctrlr.subsys = (struct spdk_nvmf_subsystem *)&subsystem;
2782 : 4 : ctrlr.listener = &listener;
2783 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
2784 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
2785 : :
2786 : 4 : transport.opts.zcopy = true;
2787 : :
2788 : 4 : group.thread = spdk_get_thread();
2789 : 4 : group.num_sgroups = 1;
2790 : 4 : sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2791 : 4 : sgroups.num_ns = 1;
2792 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2793 : 4 : ns_info.channel = &io_ch;
2794 : 4 : sgroups.ns_info = &ns_info;
2795 : 4 : TAILQ_INIT(&sgroups.queued);
2796 : 4 : group.sgroups = &sgroups;
2797 : 4 : TAILQ_INIT(&qpair.outstanding);
2798 : :
2799 : 4 : qpair.ctrlr = &ctrlr;
2800 : 4 : qpair.group = &group;
2801 : 4 : qpair.transport = &transport;
2802 : 4 : qpair.qid = 1;
2803 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2804 : :
2805 : 4 : cmd.nsid = 1;
2806 : :
2807 : 4 : req.qpair = &qpair;
2808 : 4 : req.cmd = (union nvmf_h2c_msg *)&cmd;
2809 : 4 : req.rsp = &rsp;
2810 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2811 : 4 : cmd.opc = SPDK_NVME_OPC_READ;
2812 : :
2813 : : /* Fail because no controller */
2814 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2815 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2816 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
2817 : 4 : qpair.ctrlr = NULL;
2818 : 4 : spdk_nvmf_request_zcopy_start(&req);
2819 : 4 : CU_ASSERT_EQUAL(req.zcopy_phase, NVMF_ZCOPY_PHASE_INIT_FAILED);
2820 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
2821 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR);
2822 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2823 : 4 : qpair.ctrlr = &ctrlr;
2824 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2825 : :
2826 : : /* Fail because bad NSID */
2827 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2828 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2829 : 4 : cmd.nsid = 0;
2830 : 4 : spdk_nvmf_request_zcopy_start(&req);
2831 : 4 : CU_ASSERT_EQUAL(req.zcopy_phase, NVMF_ZCOPY_PHASE_INIT_FAILED);
2832 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
2833 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
2834 : 4 : cmd.nsid = 1;
2835 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2836 : :
2837 : : /* Fail because bad Channel */
2838 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2839 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2840 : 4 : ns_info.channel = NULL;
2841 : 4 : spdk_nvmf_request_zcopy_start(&req);
2842 : 4 : CU_ASSERT_EQUAL(req.zcopy_phase, NVMF_ZCOPY_PHASE_INIT_FAILED);
2843 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
2844 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
2845 : 4 : ns_info.channel = &io_ch;
2846 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2847 : :
2848 : : /* Queue the request because NSID is not active */
2849 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2850 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2851 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_PAUSING;
2852 : 4 : spdk_nvmf_request_zcopy_start(&req);
2853 : 4 : CU_ASSERT_EQUAL(req.zcopy_phase, NVMF_ZCOPY_PHASE_INIT);
2854 : 4 : CU_ASSERT_EQUAL(TAILQ_FIRST(&sgroups.queued), &req);
2855 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2856 [ + + ]: 4 : TAILQ_REMOVE(&sgroups.queued, &req, link);
2857 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2858 : :
2859 : : /* Fail because QPair is not active */
2860 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2861 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2862 : 4 : qpair.state = SPDK_NVMF_QPAIR_DEACTIVATING;
2863 : 4 : qpair.state_cb = qpair_state_change_done;
2864 : 4 : spdk_nvmf_request_zcopy_start(&req);
2865 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT_FAILED);
2866 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2867 : 4 : qpair.state_cb = NULL;
2868 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2869 : :
2870 : : /* Fail because nvmf_bdev_ctrlr_zcopy_start fails */
2871 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2872 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2873 : 4 : cmd.cdw10 = bdev.blockcnt; /* SLBA: CDW10 and CDW11 */
2874 : 4 : cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */
2875 : 4 : req.length = (cmd.cdw12 + 1) * bdev.blocklen;
2876 : 4 : spdk_nvmf_request_zcopy_start(&req);
2877 : 4 : CU_ASSERT_EQUAL(req.zcopy_phase, NVMF_ZCOPY_PHASE_INIT_FAILED);
2878 : 4 : cmd.cdw10 = 0;
2879 : 4 : cmd.cdw12 = 0;
2880 : 4 : req.zcopy_phase = NVMF_ZCOPY_PHASE_NONE;
2881 : :
2882 : : /* Success */
2883 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2884 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2885 : 4 : spdk_nvmf_request_zcopy_start(&req);
2886 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_EXECUTE);
2887 : :
2888 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
2889 : 4 : }
2890 : :
2891 : : static void
2892 : 4 : test_zcopy_read(void)
2893 : : {
2894 : 4 : struct spdk_nvmf_request req = {};
2895 : 4 : struct spdk_nvmf_qpair qpair = {};
2896 : 4 : struct spdk_nvmf_transport transport = {};
2897 : 4 : struct spdk_nvme_cmd cmd = {};
2898 : 4 : union nvmf_c2h_msg rsp = {};
2899 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2900 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2901 : 4 : struct spdk_nvmf_ns ns = {};
2902 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
2903 : 3 : enum spdk_nvme_ana_state ana_state[1];
2904 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
2905 : 4 : struct spdk_bdev bdev = { .blockcnt = 100, .blocklen = 512};
2906 : :
2907 : 4 : struct spdk_nvmf_poll_group group = {};
2908 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2909 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
2910 : 4 : struct spdk_io_channel io_ch = {};
2911 : :
2912 : 4 : ns.bdev = &bdev;
2913 : 4 : ns.zcopy = true;
2914 : 4 : ns.anagrpid = 1;
2915 : :
2916 : 4 : subsystem.id = 0;
2917 : 4 : subsystem.max_nsid = 1;
2918 : 4 : subsys_ns[0] = &ns;
2919 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
2920 : :
2921 : 4 : listener.ana_state[0] = SPDK_NVME_ANA_OPTIMIZED_STATE;
2922 : :
2923 : : /* Enable controller */
2924 : 4 : ctrlr.vcprop.cc.bits.en = 1;
2925 : 4 : ctrlr.subsys = (struct spdk_nvmf_subsystem *)&subsystem;
2926 : 4 : ctrlr.listener = &listener;
2927 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
2928 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
2929 : :
2930 : 4 : transport.opts.zcopy = true;
2931 : :
2932 : 4 : group.thread = spdk_get_thread();
2933 : 4 : group.num_sgroups = 1;
2934 : 4 : sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2935 : 4 : sgroups.num_ns = 1;
2936 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
2937 : 4 : ns_info.channel = &io_ch;
2938 : 4 : sgroups.ns_info = &ns_info;
2939 : 4 : TAILQ_INIT(&sgroups.queued);
2940 : 4 : group.sgroups = &sgroups;
2941 : 4 : TAILQ_INIT(&qpair.outstanding);
2942 : :
2943 : 4 : qpair.ctrlr = &ctrlr;
2944 : 4 : qpair.group = &group;
2945 : 4 : qpair.transport = &transport;
2946 : 4 : qpair.qid = 1;
2947 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
2948 : :
2949 : 4 : cmd.nsid = 1;
2950 : :
2951 : 4 : req.qpair = &qpair;
2952 : 4 : req.cmd = (union nvmf_h2c_msg *)&cmd;
2953 : 4 : req.rsp = &rsp;
2954 : 4 : cmd.opc = SPDK_NVME_OPC_READ;
2955 : :
2956 : : /* Prepare for zcopy */
2957 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
2958 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
2959 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == NULL);
2960 : 4 : CU_ASSERT(ns_info.io_outstanding == 0);
2961 : :
2962 : : /* Perform the zcopy start */
2963 : 4 : spdk_nvmf_request_zcopy_start(&req);
2964 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_EXECUTE);
2965 : 4 : CU_ASSERT(req.zcopy_bdev_io == zcopy_start_bdev_io_read);
2966 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == &req);
2967 : 4 : CU_ASSERT(ns_info.io_outstanding == 1);
2968 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
2969 : :
2970 : : /* Perform the zcopy end */
2971 : 4 : spdk_nvmf_request_zcopy_end(&req, false);
2972 : 4 : CU_ASSERT(req.zcopy_bdev_io == NULL);
2973 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_COMPLETE);
2974 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == NULL);
2975 : 4 : CU_ASSERT(ns_info.io_outstanding == 0);
2976 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
2977 : :
2978 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
2979 : 4 : }
2980 : :
2981 : : static void
2982 : 4 : test_zcopy_write(void)
2983 : : {
2984 : 4 : struct spdk_nvmf_request req = {};
2985 : 4 : struct spdk_nvmf_qpair qpair = {};
2986 : 4 : struct spdk_nvmf_transport transport = {};
2987 : 4 : struct spdk_nvme_cmd cmd = {};
2988 : 4 : union nvmf_c2h_msg rsp = {};
2989 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
2990 : 4 : struct spdk_nvmf_subsystem subsystem = {};
2991 : 4 : struct spdk_nvmf_ns ns = {};
2992 : 4 : struct spdk_nvmf_ns *subsys_ns[1] = {};
2993 : 3 : enum spdk_nvme_ana_state ana_state[1];
2994 : 4 : struct spdk_nvmf_subsystem_listener listener = { .ana_state = ana_state };
2995 : 4 : struct spdk_bdev bdev = { .blockcnt = 100, .blocklen = 512};
2996 : :
2997 : 4 : struct spdk_nvmf_poll_group group = {};
2998 : 4 : struct spdk_nvmf_subsystem_poll_group sgroups = {};
2999 : 4 : struct spdk_nvmf_subsystem_pg_ns_info ns_info = {};
3000 : 4 : struct spdk_io_channel io_ch = {};
3001 : :
3002 : 4 : ns.bdev = &bdev;
3003 : 4 : ns.zcopy = true;
3004 : 4 : ns.anagrpid = 1;
3005 : :
3006 : 4 : subsystem.id = 0;
3007 : 4 : subsystem.max_nsid = 1;
3008 : 4 : subsys_ns[0] = &ns;
3009 : 4 : subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns;
3010 : :
3011 : 4 : listener.ana_state[0] = SPDK_NVME_ANA_OPTIMIZED_STATE;
3012 : :
3013 : : /* Enable controller */
3014 : 4 : ctrlr.vcprop.cc.bits.en = 1;
3015 : 4 : ctrlr.subsys = (struct spdk_nvmf_subsystem *)&subsystem;
3016 : 4 : ctrlr.listener = &listener;
3017 : 4 : ctrlr.visible_ns = spdk_bit_array_create(1);
3018 : 4 : spdk_bit_array_set(ctrlr.visible_ns, 0);
3019 : :
3020 : 4 : transport.opts.zcopy = true;
3021 : :
3022 : 4 : group.thread = spdk_get_thread();
3023 : 4 : group.num_sgroups = 1;
3024 : 4 : sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
3025 : 4 : sgroups.num_ns = 1;
3026 : 4 : ns_info.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
3027 : 4 : ns_info.channel = &io_ch;
3028 : 4 : sgroups.ns_info = &ns_info;
3029 : 4 : TAILQ_INIT(&sgroups.queued);
3030 : 4 : group.sgroups = &sgroups;
3031 : 4 : TAILQ_INIT(&qpair.outstanding);
3032 : :
3033 : 4 : qpair.ctrlr = &ctrlr;
3034 : 4 : qpair.group = &group;
3035 : 4 : qpair.transport = &transport;
3036 : 4 : qpair.qid = 1;
3037 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
3038 : :
3039 : 4 : cmd.nsid = 1;
3040 : :
3041 : 4 : req.qpair = &qpair;
3042 : 4 : req.cmd = (union nvmf_h2c_msg *)&cmd;
3043 : 4 : req.rsp = &rsp;
3044 : 4 : cmd.opc = SPDK_NVME_OPC_WRITE;
3045 : :
3046 : : /* Prepare for zcopy */
3047 : 4 : CU_ASSERT(nvmf_ctrlr_use_zcopy(&req));
3048 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_INIT);
3049 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == NULL);
3050 : 4 : CU_ASSERT(ns_info.io_outstanding == 0);
3051 : :
3052 : : /* Perform the zcopy start */
3053 : 4 : spdk_nvmf_request_zcopy_start(&req);
3054 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_EXECUTE);
3055 : 4 : CU_ASSERT(req.zcopy_bdev_io == zcopy_start_bdev_io_write);
3056 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == &req);
3057 : 4 : CU_ASSERT(ns_info.io_outstanding == 1);
3058 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
3059 : :
3060 : : /* Perform the zcopy end */
3061 : 4 : spdk_nvmf_request_zcopy_end(&req, true);
3062 : 4 : CU_ASSERT(req.zcopy_bdev_io == NULL);
3063 : 4 : CU_ASSERT(req.zcopy_phase == NVMF_ZCOPY_PHASE_COMPLETE);
3064 : 4 : CU_ASSERT(qpair.outstanding.tqh_first == NULL);
3065 : 4 : CU_ASSERT(ns_info.io_outstanding == 0);
3066 : 4 : CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
3067 : :
3068 : 4 : spdk_bit_array_free(&ctrlr.visible_ns);
3069 : 4 : }
3070 : :
3071 : : static void
3072 : 4 : test_nvmf_property_set(void)
3073 : : {
3074 : : int rc;
3075 : 4 : struct spdk_nvmf_request req = {};
3076 : 4 : struct spdk_nvmf_qpair qpair = {};
3077 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
3078 : 4 : union nvmf_h2c_msg cmd = {};
3079 : 4 : union nvmf_c2h_msg rsp = {};
3080 : :
3081 : 4 : req.qpair = &qpair;
3082 : 4 : qpair.ctrlr = &ctrlr;
3083 : 4 : req.cmd = &cmd;
3084 : 4 : req.rsp = &rsp;
3085 : :
3086 : : /* Invalid parameters */
3087 : 4 : cmd.prop_set_cmd.attrib.size = SPDK_NVMF_PROP_SIZE_4;
3088 : 4 : cmd.prop_set_cmd.ofst = offsetof(struct spdk_nvme_registers, vs);
3089 : :
3090 : 4 : rc = nvmf_property_set(&req);
3091 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3092 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
3093 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
3094 : :
3095 : 4 : cmd.prop_set_cmd.ofst = offsetof(struct spdk_nvme_registers, intms);
3096 : :
3097 : 4 : rc = nvmf_property_get(&req);
3098 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3099 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
3100 : 4 : CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM);
3101 : :
3102 : : /* Set cc with same property size */
3103 [ - + ]: 4 : memset(req.rsp, 0, sizeof(union nvmf_c2h_msg));
3104 : 4 : cmd.prop_set_cmd.ofst = offsetof(struct spdk_nvme_registers, cc);
3105 : :
3106 : 4 : rc = nvmf_property_set(&req);
3107 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3108 : :
3109 : : /* Emulate cc data */
3110 : 4 : ctrlr.vcprop.cc.raw = 0xDEADBEEF;
3111 : :
3112 : 4 : rc = nvmf_property_get(&req);
3113 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3114 : 4 : CU_ASSERT(req.rsp->prop_get_rsp.value.u64 == 0xDEADBEEF);
3115 : :
3116 : : /* Set asq with different property size */
3117 [ - + ]: 4 : memset(req.rsp, 0, sizeof(union nvmf_c2h_msg));
3118 : 4 : cmd.prop_set_cmd.attrib.size = SPDK_NVMF_PROP_SIZE_4;
3119 : 4 : cmd.prop_set_cmd.ofst = offsetof(struct spdk_nvme_registers, asq);
3120 : :
3121 : 4 : rc = nvmf_property_set(&req);
3122 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3123 : :
3124 : : /* Emulate asq data */
3125 : 4 : ctrlr.vcprop.asq = 0xAADDADBEEF;
3126 : :
3127 : 4 : rc = nvmf_property_get(&req);
3128 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3129 : 4 : CU_ASSERT(req.rsp->prop_get_rsp.value.u64 == 0xDDADBEEF);
3130 : 4 : }
3131 : :
3132 : : static void
3133 : 4 : test_nvmf_ctrlr_get_features_host_behavior_support(void)
3134 : : {
3135 : : int rc;
3136 : 4 : struct spdk_nvmf_request req = {};
3137 : 4 : struct spdk_nvmf_qpair qpair = {};
3138 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
3139 : 4 : struct spdk_nvme_host_behavior behavior = {};
3140 : 4 : union nvmf_h2c_msg cmd = {};
3141 : 4 : union nvmf_c2h_msg rsp = {};
3142 : :
3143 : 4 : qpair.ctrlr = &ctrlr;
3144 : 4 : req.qpair = &qpair;
3145 : 4 : req.cmd = &cmd;
3146 : 4 : req.rsp = &rsp;
3147 : :
3148 : : /* Invalid data */
3149 : 4 : req.length = sizeof(struct spdk_nvme_host_behavior);
3150 : 4 : req.iovcnt = 0;
3151 : :
3152 : 4 : rc = nvmf_ctrlr_get_features_host_behavior_support(&req);
3153 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3154 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3155 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3156 : :
3157 : : /* Wrong structure length */
3158 : 4 : req.length = sizeof(struct spdk_nvme_host_behavior) - 1;
3159 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &behavior, req.length);
3160 : :
3161 : 4 : rc = nvmf_ctrlr_get_features_host_behavior_support(&req);
3162 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3163 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3164 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3165 : :
3166 : : /* Get Features Host Behavior Support Success */
3167 : 4 : req.length = sizeof(struct spdk_nvme_host_behavior);
3168 : 4 : SPDK_IOV_ONE(req.iov, &req.iovcnt, &behavior, req.length);
3169 : :
3170 : 4 : ctrlr.acre_enabled = true;
3171 : 4 : ctrlr.lbafee_enabled = true;
3172 : 4 : behavior.acre = false;
3173 : 4 : behavior.lbafee = false;
3174 : :
3175 : 4 : rc = nvmf_ctrlr_get_features_host_behavior_support(&req);
3176 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3177 : 4 : CU_ASSERT(behavior.acre == true);
3178 : 4 : CU_ASSERT(behavior.lbafee == true);
3179 : 4 : }
3180 : :
3181 : : static void
3182 : 4 : test_nvmf_ctrlr_set_features_host_behavior_support(void)
3183 : : {
3184 : : int rc;
3185 : 4 : struct spdk_nvmf_request req = {};
3186 : 4 : struct spdk_nvmf_qpair qpair = {};
3187 : 4 : struct spdk_nvmf_ctrlr ctrlr = {};
3188 : 4 : struct spdk_nvme_host_behavior host_behavior = {};
3189 : 4 : union nvmf_h2c_msg cmd = {};
3190 : 4 : union nvmf_c2h_msg rsp = {};
3191 : :
3192 : 4 : qpair.ctrlr = &ctrlr;
3193 : 4 : req.qpair = &qpair;
3194 : 4 : req.cmd = &cmd;
3195 : 4 : req.rsp = &rsp;
3196 : 4 : req.iov[0].iov_base = &host_behavior;
3197 : 4 : req.iov[0].iov_len = sizeof(host_behavior);
3198 : :
3199 : : /* Invalid iovcnt */
3200 : 4 : req.iovcnt = 0;
3201 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3202 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3203 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3204 : :
3205 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3206 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3207 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3208 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3209 : :
3210 : : /* Invalid iov_len */
3211 : 4 : req.iovcnt = 1;
3212 : 4 : req.iov[0].iov_len = 0;
3213 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3214 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3215 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3216 : :
3217 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3218 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3219 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3220 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3221 : :
3222 : : /* acre is false but lbafee is true */
3223 : 4 : host_behavior.acre = 0;
3224 : 4 : host_behavior.lbafee = 1;
3225 : 4 : req.iov[0].iov_len = sizeof(struct spdk_nvme_host_behavior);
3226 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3227 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3228 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3229 : :
3230 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3231 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3232 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3233 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
3234 [ - + ]: 4 : CU_ASSERT(ctrlr.acre_enabled == false);
3235 [ - + ]: 4 : CU_ASSERT(ctrlr.lbafee_enabled == true);
3236 : :
3237 : : /* acre is true but lbafee is false */
3238 : 4 : host_behavior.acre = 1;
3239 : 4 : host_behavior.lbafee = 0;
3240 : 4 : req.iov[0].iov_len = sizeof(struct spdk_nvme_host_behavior);
3241 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3242 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3243 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3244 : :
3245 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3246 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3247 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3248 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS);
3249 [ - + ]: 4 : CU_ASSERT(ctrlr.acre_enabled == true);
3250 [ - + ]: 4 : CU_ASSERT(ctrlr.lbafee_enabled == false);
3251 : :
3252 : : /* Invalid acre */
3253 : 4 : host_behavior.acre = 2;
3254 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3255 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3256 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3257 : :
3258 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3259 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3260 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3261 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3262 : :
3263 : : /* Invalid lbafee */
3264 : 4 : host_behavior.lbafee = 3;
3265 : 4 : rc = SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS;
3266 : 4 : req.rsp->nvme_cpl.status.sct = SPDK_NVME_SCT_GENERIC;
3267 : 4 : req.rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS;
3268 : :
3269 : 4 : rc = nvmf_ctrlr_set_features_host_behavior_support(&req);
3270 : 4 : CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE);
3271 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC);
3272 : 4 : CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD);
3273 : 4 : }
3274 : :
3275 : : static void
3276 : 4 : test_nvmf_ctrlr_ns_attachment(void)
3277 : : {
3278 : 4 : struct spdk_nvmf_subsystem subsystem = {};
3279 : 4 : struct spdk_nvmf_ns ns1 = {
3280 : : .nsid = 1,
3281 : : .always_visible = false
3282 : : };
3283 : 4 : struct spdk_nvmf_ns ns3 = {
3284 : : .nsid = 3,
3285 : : .always_visible = false
3286 : : };
3287 : 4 : struct spdk_nvmf_ctrlr ctrlrA = {
3288 : : .subsys = &subsystem
3289 : : };
3290 : 4 : struct spdk_nvmf_ctrlr ctrlrB = {
3291 : : .subsys = &subsystem
3292 : : };
3293 : : struct spdk_nvmf_host *host;
3294 : : uint32_t nsid;
3295 : :
3296 : 4 : subsystem.max_nsid = 3;
3297 : 4 : subsystem.ns = calloc(subsystem.max_nsid, sizeof(subsystem.ns));
3298 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(subsystem.ns != NULL);
3299 : :
3300 : : /* nsid = 2 -> unallocated, nsid = 1,3 -> allocated */
3301 : 4 : subsystem.ns[0] = &ns1;
3302 : 4 : subsystem.ns[2] = &ns3;
3303 : :
3304 [ - + ]: 4 : snprintf(ctrlrA.hostnqn, sizeof(ctrlrA.hostnqn), "nqn.2016-06.io.spdk:host1");
3305 : 4 : ctrlrA.visible_ns = spdk_bit_array_create(subsystem.max_nsid);
3306 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlrA.visible_ns != NULL);
3307 [ - + ]: 4 : snprintf(ctrlrB.hostnqn, sizeof(ctrlrB.hostnqn), "nqn.2016-06.io.spdk:host2");
3308 : 4 : ctrlrB.visible_ns = spdk_bit_array_create(subsystem.max_nsid);
3309 [ + + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlrB.visible_ns != NULL);
3310 : :
3311 : : /* Do not auto attach and no cold attach of any ctrlr */
3312 : 4 : nsid = 1;
3313 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == NULL);
3314 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3315 : 4 : nvmf_ctrlr_init_visible_ns(&ctrlrA);
3316 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3317 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3318 : 4 : nsid = 3;
3319 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3320 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3321 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == NULL);
3322 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3323 : :
3324 : : /* Cold attach ctrlrA to namespace 1 */
3325 : 4 : nsid = 1;
3326 : 4 : host = calloc(1, sizeof(*host));
3327 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(host != NULL);
3328 [ - + ]: 4 : snprintf(host->nqn, sizeof(host->nqn), "%s", ctrlrA.hostnqn);
3329 [ - + ]: 4 : TAILQ_INSERT_HEAD(&ns1.hosts, host, link);
3330 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == host);
3331 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3332 : 4 : nvmf_ctrlr_init_visible_ns(&ctrlrA);
3333 : 4 : CU_ASSERT(spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3334 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3335 : 4 : nsid = 3;
3336 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3337 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3338 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == host);
3339 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3340 : :
3341 : : /* Detach ctrlrA from namespace 1 */
3342 : 4 : nsid = 1;
3343 : 4 : spdk_bit_array_clear(ctrlrA.visible_ns, nsid - 1);
3344 [ - + ]: 4 : TAILQ_REMOVE(&ns1.hosts, host, link);
3345 : 4 : free(host);
3346 : :
3347 : : /* Auto attach any ctrlr to namespace 2 */
3348 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == NULL);
3349 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3350 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3351 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3352 : 4 : nsid = 3;
3353 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3354 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3355 : 4 : ns1.always_visible = true;
3356 : 4 : nvmf_ctrlr_init_visible_ns(&ctrlrA);
3357 : 4 : nsid = 1;
3358 : 4 : CU_ASSERT(spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3359 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3360 : 4 : nsid = 3;
3361 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3362 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3363 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == NULL);
3364 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3365 : 4 : nvmf_ctrlr_init_visible_ns(&ctrlrB);
3366 : 4 : nsid = 1;
3367 : 4 : CU_ASSERT(spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3368 : 4 : CU_ASSERT(spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3369 : 4 : nsid = 3;
3370 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrA.visible_ns, nsid - 1));
3371 : 4 : CU_ASSERT(!spdk_bit_array_get(ctrlrB.visible_ns, nsid - 1));
3372 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns1, ctrlrA.hostnqn) == NULL);
3373 : 4 : CU_ASSERT(nvmf_ns_find_host(&ns3, ctrlrA.hostnqn) == NULL);
3374 : :
3375 : 4 : free(ctrlrA.visible_ns);
3376 : 4 : free(ctrlrB.visible_ns);
3377 : 4 : free(subsystem.ns);
3378 : 4 : }
3379 : :
3380 : : static void
3381 : 4 : test_nvmf_check_qpair_active(void)
3382 : : {
3383 : 4 : union nvmf_c2h_msg rsp = {};
3384 : 4 : union nvmf_h2c_msg cmd = {};
3385 : 4 : struct spdk_nvmf_qpair qpair = { .outstanding = TAILQ_HEAD_INITIALIZER(qpair.outstanding) };
3386 : 4 : struct spdk_nvmf_request req = { .qpair = &qpair, .cmd = &cmd, .rsp = &rsp };
3387 : : size_t i;
3388 : :
3389 : : /* qpair is active */
3390 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
3391 : 4 : qpair.state = SPDK_NVMF_QPAIR_ENABLED;
3392 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), true);
3393 : :
3394 : : /* qpair is connecting - CONNECT is allowed */
3395 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FABRIC;
3396 : 4 : cmd.nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT;
3397 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
3398 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), true);
3399 : :
3400 : : /* qpair is connecting - other commands are disallowed */
3401 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
3402 : 4 : qpair.state = SPDK_NVMF_QPAIR_CONNECTING;
3403 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), false);
3404 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
3405 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR);
3406 : :
3407 : : /* qpair is authenticating - AUTHENTICATION_SEND is allowed */
3408 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FABRIC;
3409 : 4 : cmd.nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_AUTHENTICATION_SEND;
3410 : 4 : qpair.state = SPDK_NVMF_QPAIR_AUTHENTICATING;
3411 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), true);
3412 : :
3413 : : /* qpair is authenticating - AUTHENTICATION_RECV is allowed */
3414 : 4 : cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FABRIC;
3415 : 4 : cmd.nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_AUTHENTICATION_RECV;
3416 : 4 : qpair.state = SPDK_NVMF_QPAIR_AUTHENTICATING;
3417 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), true);
3418 : :
3419 : : /* qpair is authenticating - other commands are disallowed */
3420 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
3421 : 4 : qpair.state = SPDK_NVMF_QPAIR_AUTHENTICATING;
3422 : 4 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), false);
3423 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_COMMAND_SPECIFIC);
3424 : 4 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVMF_FABRIC_SC_AUTH_REQUIRED);
3425 : :
3426 : : /* qpair is in one of the other states - all commands are disallowed */
3427 : 4 : int disallowed_states[] = {
3428 : : SPDK_NVMF_QPAIR_UNINITIALIZED,
3429 : : SPDK_NVMF_QPAIR_DEACTIVATING,
3430 : : SPDK_NVMF_QPAIR_ERROR,
3431 : : };
3432 : 4 : qpair.state_cb = qpair_state_change_done;
3433 : 4 : cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ;
3434 [ + + ]: 16 : for (i = 0; i < SPDK_COUNTOF(disallowed_states); ++i) {
3435 : 12 : qpair.state = disallowed_states[i];
3436 : 12 : CU_ASSERT_EQUAL(nvmf_check_qpair_active(&req), false);
3437 : 12 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sct, SPDK_NVME_SCT_GENERIC);
3438 : 12 : CU_ASSERT_EQUAL(rsp.nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR);
3439 : 3 : }
3440 : 4 : }
3441 : :
3442 : : int
3443 : 4 : main(int argc, char **argv)
3444 : : {
3445 : 4 : CU_pSuite suite = NULL;
3446 : : unsigned int num_failures;
3447 : :
3448 : 4 : CU_initialize_registry();
3449 : :
3450 : 4 : suite = CU_add_suite("nvmf", NULL, NULL);
3451 : 4 : CU_ADD_TEST(suite, test_get_log_page);
3452 : 4 : CU_ADD_TEST(suite, test_process_fabrics_cmd);
3453 : 4 : CU_ADD_TEST(suite, test_connect);
3454 : 4 : CU_ADD_TEST(suite, test_get_ns_id_desc_list);
3455 : 4 : CU_ADD_TEST(suite, test_identify_ns);
3456 : 4 : CU_ADD_TEST(suite, test_identify_ns_iocs_specific);
3457 : 4 : CU_ADD_TEST(suite, test_reservation_write_exclusive);
3458 : 4 : CU_ADD_TEST(suite, test_reservation_exclusive_access);
3459 : 4 : CU_ADD_TEST(suite, test_reservation_write_exclusive_regs_only_and_all_regs);
3460 : 4 : CU_ADD_TEST(suite, test_reservation_exclusive_access_regs_only_and_all_regs);
3461 : 4 : CU_ADD_TEST(suite, test_reservation_notification_log_page);
3462 : 4 : CU_ADD_TEST(suite, test_get_dif_ctx);
3463 : 4 : CU_ADD_TEST(suite, test_set_get_features);
3464 : 4 : CU_ADD_TEST(suite, test_identify_ctrlr);
3465 : 4 : CU_ADD_TEST(suite, test_identify_ctrlr_iocs_specific);
3466 : 4 : CU_ADD_TEST(suite, test_custom_admin_cmd);
3467 : 4 : CU_ADD_TEST(suite, test_fused_compare_and_write);
3468 : 4 : CU_ADD_TEST(suite, test_multi_async_event_reqs);
3469 : 4 : CU_ADD_TEST(suite, test_get_ana_log_page_one_ns_per_anagrp);
3470 : 4 : CU_ADD_TEST(suite, test_get_ana_log_page_multi_ns_per_anagrp);
3471 : 4 : CU_ADD_TEST(suite, test_multi_async_events);
3472 : 4 : CU_ADD_TEST(suite, test_rae);
3473 : 4 : CU_ADD_TEST(suite, test_nvmf_ctrlr_create_destruct);
3474 : 4 : CU_ADD_TEST(suite, test_nvmf_ctrlr_use_zcopy);
3475 : 4 : CU_ADD_TEST(suite, test_spdk_nvmf_request_zcopy_start);
3476 : 4 : CU_ADD_TEST(suite, test_zcopy_read);
3477 : 4 : CU_ADD_TEST(suite, test_zcopy_write);
3478 : 4 : CU_ADD_TEST(suite, test_nvmf_property_set);
3479 : 4 : CU_ADD_TEST(suite, test_nvmf_ctrlr_get_features_host_behavior_support);
3480 : 4 : CU_ADD_TEST(suite, test_nvmf_ctrlr_set_features_host_behavior_support);
3481 : 4 : CU_ADD_TEST(suite, test_nvmf_ctrlr_ns_attachment);
3482 : 4 : CU_ADD_TEST(suite, test_nvmf_check_qpair_active);
3483 : :
3484 : 4 : allocate_threads(1);
3485 : 4 : set_thread(0);
3486 : :
3487 : 4 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
3488 : 4 : CU_cleanup_registry();
3489 : :
3490 : 4 : free_threads();
3491 : :
3492 : 4 : return num_failures;
3493 : : }
|