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