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