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