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