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