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) 2018-2019, 2021 Mellanox Technologies LTD. All rights reserved.
4 : : * Copyright (c) 2021, 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk/bdev.h"
10 : : #include "spdk/bit_array.h"
11 : : #include "spdk/thread.h"
12 : : #include "spdk/nvmf.h"
13 : : #include "spdk/endian.h"
14 : : #include "spdk/string.h"
15 : : #include "spdk/log.h"
16 : : #include "spdk_internal/usdt.h"
17 : :
18 : : #include "nvmf_internal.h"
19 : : #include "transport.h"
20 : :
21 : 963 : SPDK_LOG_REGISTER_COMPONENT(nvmf)
22 : :
23 : : #define SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS 1024
24 : :
25 : : static TAILQ_HEAD(, spdk_nvmf_tgt) g_nvmf_tgts = TAILQ_HEAD_INITIALIZER(g_nvmf_tgts);
26 : :
27 : : typedef void (*nvmf_qpair_disconnect_cpl)(void *ctx, int status);
28 : :
29 : : /* supplied to a single call to nvmf_qpair_disconnect */
30 : : struct nvmf_qpair_disconnect_ctx {
31 : : struct spdk_nvmf_qpair *qpair;
32 : : struct spdk_nvmf_ctrlr *ctrlr;
33 : : uint16_t qid;
34 : : };
35 : :
36 : : /*
37 : : * There are several times when we need to iterate through the list of all qpairs and selectively delete them.
38 : : * In order to do this sequentially without overlap, we must provide a context to recover the next qpair from
39 : : * to enable calling nvmf_qpair_disconnect on the next desired qpair.
40 : : */
41 : : struct nvmf_qpair_disconnect_many_ctx {
42 : : struct spdk_nvmf_subsystem *subsystem;
43 : : struct spdk_nvmf_poll_group *group;
44 : : spdk_nvmf_poll_group_mod_done cpl_fn;
45 : : void *cpl_ctx;
46 : : };
47 : :
48 : : static struct spdk_nvmf_referral *
49 : 39 : nvmf_tgt_find_referral(struct spdk_nvmf_tgt *tgt,
50 : : const struct spdk_nvme_transport_id *trid)
51 : : {
52 : : struct spdk_nvmf_referral *referral;
53 : :
54 [ + + # # : 60 : TAILQ_FOREACH(referral, &tgt->referrals, link) {
# # # # #
# # # #
# ]
55 [ + + # # ]: 39 : if (spdk_nvme_transport_id_compare(&referral->trid, trid) == 0) {
56 : 18 : return referral;
57 : : }
58 : 0 : }
59 : :
60 : 21 : return NULL;
61 : 0 : }
62 : :
63 : : int
64 : 21 : spdk_nvmf_tgt_add_referral(struct spdk_nvmf_tgt *tgt,
65 : : const struct spdk_nvmf_referral_opts *uopts)
66 : : {
67 : : struct spdk_nvmf_referral *referral;
68 : 21 : struct spdk_nvmf_referral_opts opts = {};
69 : 21 : struct spdk_nvme_transport_id *trid = &opts.trid;
70 : :
71 [ - + - + : 21 : memcpy(&opts, uopts, spdk_min(uopts->size, sizeof(opts)));
# # # # #
# # # #
# ]
72 [ + + # # : 21 : if (trid->subnqn[0] == '\0') {
# # # # #
# ]
73 [ - + ]: 15 : snprintf(trid->subnqn, sizeof(trid->subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);
74 : 0 : }
75 : :
76 [ - + # # ]: 21 : if (!nvmf_nqn_is_valid(trid->subnqn)) {
77 : 0 : SPDK_ERRLOG("Invalid subsystem NQN\n");
78 : 0 : return -EINVAL;
79 : : }
80 : :
81 : : /* If the entry already exists, just ignore it. */
82 [ - + ]: 21 : if (nvmf_tgt_find_referral(tgt, trid)) {
83 : 0 : return 0;
84 : : }
85 : :
86 : 21 : referral = calloc(1, sizeof(*referral));
87 [ - + ]: 21 : if (!referral) {
88 : 0 : SPDK_ERRLOG("Failed to allocate memory for a referral\n");
89 : 0 : return -ENOMEM;
90 : : }
91 : :
92 [ + + # # : 21 : referral->entry.subtype = nvmf_nqn_is_discovery(trid->subnqn) ?
# # # # ]
93 : : SPDK_NVMF_SUBTYPE_DISCOVERY :
94 : : SPDK_NVMF_SUBTYPE_NVME;
95 [ - + # # : 42 : referral->entry.treq.secure_channel = opts.secure_channel ?
# # # # #
# ]
96 [ - + ]: 21 : SPDK_NVMF_TREQ_SECURE_CHANNEL_REQUIRED :
97 : : SPDK_NVMF_TREQ_SECURE_CHANNEL_NOT_REQUIRED;
98 [ # # # # : 21 : referral->entry.cntlid = 0xffff;
# # ]
99 [ # # # # : 21 : referral->entry.trtype = trid->trtype;
# # # # #
# ]
100 [ # # # # : 21 : referral->entry.adrfam = trid->adrfam;
# # # # #
# ]
101 [ - + - + : 21 : memcpy(&referral->trid, trid, sizeof(struct spdk_nvme_transport_id));
# # ]
102 [ # # # # : 21 : spdk_strcpy_pad(referral->entry.subnqn, trid->subnqn, sizeof(trid->subnqn), '\0');
# # ]
103 [ # # # # : 21 : spdk_strcpy_pad(referral->entry.trsvcid, trid->trsvcid, sizeof(referral->entry.trsvcid), ' ');
# # ]
104 [ # # # # : 21 : spdk_strcpy_pad(referral->entry.traddr, trid->traddr, sizeof(referral->entry.traddr), ' ');
# # ]
105 : :
106 [ + + # # : 21 : TAILQ_INSERT_HEAD(&tgt->referrals, referral, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
107 : 21 : spdk_nvmf_send_discovery_log_notice(tgt, NULL);
108 : :
109 : 21 : return 0;
110 : 0 : }
111 : :
112 : : int
113 : 18 : spdk_nvmf_tgt_remove_referral(struct spdk_nvmf_tgt *tgt,
114 : : const struct spdk_nvmf_referral_opts *uopts)
115 : : {
116 : : struct spdk_nvmf_referral *referral;
117 : 18 : struct spdk_nvmf_referral_opts opts = {};
118 : 18 : struct spdk_nvme_transport_id *trid = &opts.trid;
119 : :
120 [ - + - + : 18 : memcpy(&opts, uopts, spdk_min(uopts->size, sizeof(opts)));
# # # # #
# # # #
# ]
121 [ + + # # : 18 : if (trid->subnqn[0] == '\0') {
# # # # #
# ]
122 [ - + ]: 12 : snprintf(trid->subnqn, sizeof(trid->subnqn), "%s", SPDK_NVMF_DISCOVERY_NQN);
123 : 0 : }
124 : :
125 : 18 : referral = nvmf_tgt_find_referral(tgt, &opts.trid);
126 [ - + ]: 18 : if (referral == NULL) {
127 : 0 : return -ENOENT;
128 : : }
129 : :
130 [ + + # # : 18 : TAILQ_REMOVE(&tgt->referrals, referral, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
131 : 18 : spdk_nvmf_send_discovery_log_notice(tgt, NULL);
132 : :
133 : 18 : free(referral);
134 : :
135 : 18 : return 0;
136 : 0 : }
137 : :
138 : : void
139 : 43302 : nvmf_qpair_set_state(struct spdk_nvmf_qpair *qpair,
140 : : enum spdk_nvmf_qpair_state state)
141 : : {
142 [ + + # # ]: 43302 : assert(qpair != NULL);
143 [ + + + - : 43302 : assert(qpair->group->thread == spdk_get_thread());
+ - + - +
- # # ]
144 : :
145 [ + - + - ]: 43302 : qpair->state = state;
146 : 43302 : }
147 : :
148 : : /*
149 : : * Reset and clean up the poll group (I/O channel code will actually free the
150 : : * group).
151 : : */
152 : : static void
153 : 1495 : nvmf_tgt_cleanup_poll_group(struct spdk_nvmf_poll_group *group)
154 : : {
155 : : struct spdk_nvmf_transport_poll_group *tgroup, *tmp;
156 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
157 : : uint32_t sid, nsid;
158 : :
159 [ + + + + : 2206 : TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) {
+ - + + +
- + - + -
+ + ]
160 [ + + + - : 711 : TAILQ_REMOVE(&group->tgroups, tgroup, link);
+ - - + #
# # # # #
# # # # #
# # # # #
# # + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
161 : 711 : nvmf_transport_poll_group_destroy(tgroup);
162 : 37 : }
163 : :
164 [ + + + - : 1507616 : for (sid = 0; sid < group->num_sgroups; sid++) {
+ + ]
165 [ + - + - : 1506121 : sgroup = &group->sgroups[sid];
+ - ]
166 : :
167 [ + + # # ]: 1506121 : assert(sgroup != NULL);
168 : :
169 [ + + + - : 1506125 : for (nsid = 0; nsid < sgroup->num_ns; nsid++) {
- + ]
170 [ + + # # : 4 : if (sgroup->ns_info[nsid].channel) {
# # # # #
# # # ]
171 [ # # # # : 4 : spdk_put_io_channel(sgroup->ns_info[nsid].channel);
# # # # #
# ]
172 [ # # # # : 4 : sgroup->ns_info[nsid].channel = NULL;
# # # # #
# ]
173 : 1 : }
174 : 1 : }
175 : :
176 [ + - + - ]: 1506121 : free(sgroup->ns_info);
177 : 73158 : }
178 : :
179 [ + - + - ]: 1495 : free(group->sgroups);
180 : :
181 [ + + + - : 1495 : if (group->destroy_cb_fn) {
+ + ]
182 [ + - + - : 1493 : group->destroy_cb_fn(group->destroy_cb_arg, 0);
+ + + - +
- + - ]
183 : 82 : }
184 : 1499 : }
185 : :
186 : : /*
187 : : * Callback to unregister a poll group from the target, and clean up its state.
188 : : */
189 : : static void
190 : 1497 : nvmf_tgt_destroy_poll_group(void *io_device, void *ctx_buf)
191 : : {
192 : 1497 : struct spdk_nvmf_tgt *tgt = io_device;
193 : 1497 : struct spdk_nvmf_poll_group *group = ctx_buf;
194 : :
195 : 332 : SPDK_DTRACE_PROBE1_TICKS(nvmf_destroy_poll_group, spdk_thread_get_id(group->thread));
196 : :
197 [ + + + - ]: 1497 : pthread_mutex_lock(&tgt->mutex);
198 [ + + + - : 1497 : TAILQ_REMOVE(&tgt->poll_groups, group, link);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
199 [ + - ]: 1497 : tgt->num_poll_groups--;
200 [ + + + - ]: 1497 : pthread_mutex_unlock(&tgt->mutex);
201 : :
202 [ + - + - : 1497 : assert(!(tgt->state == NVMF_TGT_PAUSING || tgt->state == NVMF_TGT_RESUMING));
+ - + - +
- # # ]
203 : 1497 : nvmf_tgt_cleanup_poll_group(group);
204 : 1497 : }
205 : :
206 : : static int
207 : 711 : nvmf_poll_group_add_transport(struct spdk_nvmf_poll_group *group,
208 : : struct spdk_nvmf_transport *transport)
209 : : {
210 : 711 : struct spdk_nvmf_transport_poll_group *tgroup = nvmf_get_transport_poll_group(group, transport);
211 : :
212 [ - + ]: 711 : if (tgroup != NULL) {
213 : : /* Transport already in the poll group */
214 : 0 : return 0;
215 : : }
216 : :
217 : 711 : tgroup = nvmf_transport_poll_group_create(transport, group);
218 [ + + ]: 711 : if (!tgroup) {
219 : 0 : SPDK_ERRLOG("Unable to create poll group for transport\n");
220 : 0 : return -1;
221 : : }
222 : 267 : SPDK_DTRACE_PROBE2_TICKS(nvmf_transport_poll_group_create, transport,
223 : : spdk_thread_get_id(group->thread));
224 : :
225 [ - + - + ]: 711 : tgroup->group = group;
226 [ - + - + : 711 : TAILQ_INSERT_TAIL(&group->tgroups, tgroup, link);
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + ]
227 : :
228 : 711 : return 0;
229 : 37 : }
230 : :
231 : : static int
232 : 1497 : nvmf_tgt_create_poll_group(void *io_device, void *ctx_buf)
233 : : {
234 : 1497 : struct spdk_nvmf_tgt *tgt = io_device;
235 : 1497 : struct spdk_nvmf_poll_group *group = ctx_buf;
236 : : struct spdk_nvmf_transport *transport;
237 : : struct spdk_nvmf_subsystem *subsystem;
238 : 1497 : struct spdk_thread *thread = spdk_get_thread();
239 : : uint32_t i;
240 : : int rc;
241 : :
242 [ + - + - ]: 1497 : group->tgt = tgt;
243 [ + - + - : 1497 : TAILQ_INIT(&group->tgroups);
+ - + - +
- + - + -
+ - ]
244 [ + - + - : 1497 : TAILQ_INIT(&group->qpairs);
+ - + - +
- + - + -
+ - ]
245 [ + - + - ]: 1497 : group->thread = thread;
246 [ + + + - ]: 1497 : pthread_mutex_init(&group->mutex, NULL);
247 : :
248 : 332 : SPDK_DTRACE_PROBE1_TICKS(nvmf_create_poll_group, spdk_thread_get_id(thread));
249 : :
250 [ + + + - : 1501 : TAILQ_FOREACH(transport, &tgt->transports, link) {
+ - - + #
# # # #
# ]
251 : 4 : rc = nvmf_poll_group_add_transport(group, transport);
252 [ + + ]: 4 : if (rc != 0) {
253 : 0 : nvmf_tgt_cleanup_poll_group(group);
254 : 0 : return rc;
255 : : }
256 : 1 : }
257 : :
258 [ + - + - : 1497 : group->num_sgroups = tgt->max_subsystems;
+ - + - ]
259 [ + - + - : 1497 : group->sgroups = calloc(tgt->max_subsystems, sizeof(struct spdk_nvmf_subsystem_poll_group));
+ - + - ]
260 [ + + + - : 1497 : if (!group->sgroups) {
+ - ]
261 : 0 : nvmf_tgt_cleanup_poll_group(group);
262 : 0 : return -ENOMEM;
263 : : }
264 : :
265 [ + + + - : 1518429 : for (i = 0; i < tgt->max_subsystems; i++) {
+ + ]
266 [ + - + - : 1516932 : TAILQ_INIT(&group->sgroups[i].queued);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - +
- ]
267 : 83969 : }
268 : :
269 [ + + ]: 1580 : for (subsystem = spdk_nvmf_subsystem_get_first(tgt);
270 [ + + ]: 2994 : subsystem != NULL;
271 : 1497 : subsystem = spdk_nvmf_subsystem_get_next(subsystem)) {
272 [ + + ]: 1497 : if (nvmf_poll_group_add_subsystem(group, subsystem, NULL, NULL) != 0) {
273 : 0 : nvmf_tgt_cleanup_poll_group(group);
274 : 0 : return -1;
275 : : }
276 : 83 : }
277 : :
278 [ - + - + ]: 1497 : pthread_mutex_lock(&tgt->mutex);
279 [ - + ]: 1497 : tgt->num_poll_groups++;
280 [ - + - + : 1497 : TAILQ_INSERT_TAIL(&tgt->poll_groups, group, link);
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + ]
281 [ - + - + ]: 1497 : pthread_mutex_unlock(&tgt->mutex);
282 : :
283 : 1497 : return 0;
284 : 83 : }
285 : :
286 : : static void
287 : 1492 : _nvmf_tgt_disconnect_qpairs(void *ctx)
288 : : {
289 : : struct spdk_nvmf_qpair *qpair, *qpair_tmp;
290 : 1492 : struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx;
291 [ + - + - ]: 1492 : struct spdk_nvmf_poll_group *group = qpair_ctx->group;
292 : : struct spdk_io_channel *ch;
293 : : int rc;
294 : :
295 [ + + + - : 1492 : TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, qpair_tmp) {
+ - + - #
# # # # #
+ - ]
296 : 0 : rc = spdk_nvmf_qpair_disconnect(qpair);
297 [ # # # # ]: 0 : if (rc && rc != -EINPROGRESS) {
298 : 0 : break;
299 : : }
300 : 0 : }
301 : :
302 [ + - + - : 1492 : if (TAILQ_EMPTY(&group->qpairs)) {
+ - - + ]
303 : : /* When the refcount from the channels reaches 0, nvmf_tgt_destroy_poll_group will be called. */
304 : 1492 : ch = spdk_io_channel_from_ctx(group);
305 : 1492 : spdk_put_io_channel(ch);
306 : 1492 : free(qpair_ctx);
307 : 1492 : return;
308 : : }
309 : :
310 : : /* Some qpairs are in process of being disconnected. Send a message and try to remove them again */
311 : 0 : spdk_thread_send_msg(spdk_get_thread(), _nvmf_tgt_disconnect_qpairs, ctx);
312 : 81 : }
313 : :
314 : : static void
315 : 1490 : nvmf_tgt_destroy_poll_group_qpairs(struct spdk_nvmf_poll_group *group)
316 : : {
317 : : struct nvmf_qpair_disconnect_many_ctx *ctx;
318 : :
319 : 332 : SPDK_DTRACE_PROBE1_TICKS(nvmf_destroy_poll_group_qpairs, spdk_thread_get_id(group->thread));
320 : :
321 : 1490 : ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx));
322 [ + + ]: 1490 : if (!ctx) {
323 : 0 : SPDK_ERRLOG("Failed to allocate memory for destroy poll group ctx\n");
324 : 0 : return;
325 : : }
326 : :
327 [ - + - + ]: 1490 : ctx->group = group;
328 : 1490 : _nvmf_tgt_disconnect_qpairs(ctx);
329 : 79 : }
330 : :
331 : : struct spdk_nvmf_tgt *
332 : 882 : spdk_nvmf_tgt_create(struct spdk_nvmf_target_opts *_opts)
333 : : {
334 : : struct spdk_nvmf_tgt *tgt, *tmp_tgt;
335 : 882 : struct spdk_nvmf_target_opts opts = {
336 : : .max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS,
337 : : .discovery_filter = SPDK_NVMF_TGT_DISCOVERY_MATCH_ANY,
338 : : };
339 : :
340 [ + + + - : 882 : memcpy(&opts, _opts, _opts->size);
+ - + - ]
341 [ + + - + ]: 882 : if (strnlen(opts.name, NVMF_TGT_NAME_MAX_LENGTH) == NVMF_TGT_NAME_MAX_LENGTH) {
342 : 0 : SPDK_ERRLOG("Provided target name exceeds the max length of %u.\n", NVMF_TGT_NAME_MAX_LENGTH);
343 : 0 : return NULL;
344 : : }
345 : :
346 [ + + # # : 891 : TAILQ_FOREACH(tmp_tgt, &g_nvmf_tgts, link) {
# # # # ]
347 [ - + - + : 9 : if (!strncmp(opts.name, tmp_tgt->name, NVMF_TGT_NAME_MAX_LENGTH)) {
# # # # ]
348 : 0 : SPDK_ERRLOG("Provided target name must be unique.\n");
349 : 0 : return NULL;
350 : : }
351 : 0 : }
352 : :
353 : 882 : tgt = calloc(1, sizeof(*tgt));
354 [ + + ]: 882 : if (!tgt) {
355 : 0 : return NULL;
356 : : }
357 : :
358 [ + - ]: 882 : snprintf(tgt->name, NVMF_TGT_NAME_MAX_LENGTH, "%s", opts.name);
359 : :
360 [ + + + + ]: 882 : if (!opts.max_subsystems) {
361 [ + - + - ]: 829 : tgt->max_subsystems = SPDK_NVMF_DEFAULT_MAX_SUBSYSTEMS;
362 : 66 : } else {
363 [ + - + - : 53 : tgt->max_subsystems = opts.max_subsystems;
+ - ]
364 : : }
365 : :
366 [ + - + - : 882 : tgt->crdt[0] = opts.crdt[0];
+ - + - +
- + - +
- ]
367 [ + - + - : 882 : tgt->crdt[1] = opts.crdt[1];
+ - + - +
- + - +
- ]
368 [ + - + - : 882 : tgt->crdt[2] = opts.crdt[2];
+ - + - +
- + - +
- ]
369 [ + - + - : 882 : tgt->discovery_filter = opts.discovery_filter;
+ - ]
370 [ + - + - ]: 882 : tgt->discovery_genctr = 0;
371 [ + - + - : 882 : tgt->dhchap_digests = opts.dhchap_digests;
+ - ]
372 [ + - + - : 882 : tgt->dhchap_dhgroups = opts.dhchap_dhgroups;
+ - ]
373 [ + - + - : 882 : TAILQ_INIT(&tgt->transports);
+ - + - +
- + - + -
+ - ]
374 [ + - + - : 882 : TAILQ_INIT(&tgt->poll_groups);
+ - + - +
- + - + -
+ - ]
375 [ + - + - : 882 : TAILQ_INIT(&tgt->referrals);
+ - + - +
- + - + -
+ - ]
376 [ + - + - ]: 882 : tgt->num_poll_groups = 0;
377 : :
378 [ + - + - : 882 : tgt->subsystem_ids = spdk_bit_array_create(tgt->max_subsystems);
+ - + - ]
379 [ + + + - : 882 : if (tgt->subsystem_ids == NULL) {
+ - ]
380 : 0 : free(tgt);
381 : 0 : return NULL;
382 : : }
383 : :
384 [ + - + - : 882 : RB_INIT(&tgt->subsystems);
+ - ]
385 : :
386 [ + + + - ]: 882 : pthread_mutex_init(&tgt->mutex, NULL);
387 : :
388 : 898 : spdk_io_device_register(tgt,
389 : : nvmf_tgt_create_poll_group,
390 : : nvmf_tgt_destroy_poll_group,
391 : : sizeof(struct spdk_nvmf_poll_group),
392 [ + - ]: 882 : tgt->name);
393 : :
394 [ + - + - ]: 882 : tgt->state = NVMF_TGT_RUNNING;
395 : :
396 [ + + + - : 882 : TAILQ_INSERT_HEAD(&g_nvmf_tgts, tgt, link);
+ - - + #
# # # # #
# # # # -
+ - + - +
+ - + - +
- ]
397 : :
398 : 882 : return tgt;
399 : 69 : }
400 : :
401 : : static void
402 : 1217 : _nvmf_tgt_destroy_next_transport(void *ctx)
403 : : {
404 : 1217 : struct spdk_nvmf_tgt *tgt = ctx;
405 : : struct spdk_nvmf_transport *transport;
406 : :
407 [ + + + - : 1217 : if (!TAILQ_EMPTY(&tgt->transports)) {
+ - + + ]
408 [ + - + - : 335 : transport = TAILQ_FIRST(&tgt->transports);
+ - ]
409 [ + + + - : 335 : TAILQ_REMOVE(&tgt->transports, transport, link);
+ - - + #
# # # # #
# # # # #
# # # # #
# # + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
410 : 335 : spdk_nvmf_transport_destroy(transport, _nvmf_tgt_destroy_next_transport, tgt);
411 : 36 : } else {
412 [ + - + - ]: 882 : spdk_nvmf_tgt_destroy_done_fn *destroy_cb_fn = tgt->destroy_cb_fn;
413 [ + - + - ]: 882 : void *destroy_cb_arg = tgt->destroy_cb_arg;
414 : :
415 [ + + + - ]: 882 : pthread_mutex_destroy(&tgt->mutex);
416 : 882 : free(tgt);
417 : :
418 [ + + ]: 882 : if (destroy_cb_fn) {
419 [ - + - + ]: 882 : destroy_cb_fn(destroy_cb_arg, 0);
420 : 69 : }
421 : : }
422 : 1217 : }
423 : :
424 : : static void
425 : 882 : nvmf_tgt_destroy_cb(void *io_device)
426 : : {
427 : 882 : struct spdk_nvmf_tgt *tgt = io_device;
428 : : struct spdk_nvmf_subsystem *subsystem, *subsystem_next;
429 : : int rc;
430 : : struct spdk_nvmf_referral *referral;
431 : :
432 [ + + + - : 885 : while ((referral = TAILQ_FIRST(&tgt->referrals))) {
+ - - + ]
433 [ - + # # : 3 : TAILQ_REMOVE(&tgt->referrals, referral, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
434 : 3 : free(referral);
435 : : }
436 : :
437 : 882 : nvmf_tgt_stop_mdns_prr(tgt);
438 : :
439 : : /* We will be freeing subsystems in this loop, so we always need to get the next one
440 : : * ahead of time, since we can't call get_next() on a subsystem that's been freed.
441 : : */
442 [ + + ]: 1764 : for (subsystem = spdk_nvmf_subsystem_get_first(tgt),
443 : 882 : subsystem_next = spdk_nvmf_subsystem_get_next(subsystem);
444 [ + + ]: 888 : subsystem != NULL;
445 : 6 : subsystem = subsystem_next,
446 : 6 : subsystem_next = spdk_nvmf_subsystem_get_next(subsystem_next)) {
447 : 6 : nvmf_subsystem_remove_all_listeners(subsystem, true);
448 : :
449 : 6 : rc = spdk_nvmf_subsystem_destroy(subsystem, nvmf_tgt_destroy_cb, tgt);
450 [ - + ]: 6 : if (rc) {
451 [ # # ]: 0 : if (rc == -EINPROGRESS) {
452 : : /* If rc is -EINPROGRESS, nvmf_tgt_destroy_cb will be called again when subsystem #i
453 : : * is destroyed, nvmf_tgt_destroy_cb will continue to destroy other subsystems if any */
454 : 0 : return;
455 : : } else {
456 [ # # ]: 0 : SPDK_ERRLOG("Failed to destroy subsystem %s, rc %d\n", subsystem->subnqn, rc);
457 : : }
458 : 0 : }
459 : 0 : }
460 [ + - ]: 882 : spdk_bit_array_free(&tgt->subsystem_ids);
461 : 882 : _nvmf_tgt_destroy_next_transport(tgt);
462 : 69 : }
463 : :
464 : : void
465 : 882 : spdk_nvmf_tgt_destroy(struct spdk_nvmf_tgt *tgt,
466 : : spdk_nvmf_tgt_destroy_done_fn cb_fn,
467 : : void *cb_arg)
468 : : {
469 [ + - + - : 882 : assert(!(tgt->state == NVMF_TGT_PAUSING || tgt->state == NVMF_TGT_RESUMING));
+ - + - +
- # # ]
470 : :
471 [ + - + - ]: 882 : tgt->destroy_cb_fn = cb_fn;
472 [ + - + - ]: 882 : tgt->destroy_cb_arg = cb_arg;
473 : :
474 [ + + + - : 882 : TAILQ_REMOVE(&g_nvmf_tgts, tgt, link);
+ - - + #
# # # # #
# # # # #
# # # # #
# # + - +
- + - + -
+ - + - +
- + - + -
+ - + - ]
475 : :
476 : 882 : spdk_io_device_unregister(tgt, nvmf_tgt_destroy_cb);
477 : 882 : }
478 : :
479 : : const char *
480 : 21 : spdk_nvmf_tgt_get_name(struct spdk_nvmf_tgt *tgt)
481 : : {
482 [ # # ]: 21 : return tgt->name;
483 : : }
484 : :
485 : : struct spdk_nvmf_tgt *
486 : 11658 : spdk_nvmf_get_tgt(const char *name)
487 : : {
488 : : struct spdk_nvmf_tgt *tgt;
489 : 11658 : uint32_t num_targets = 0;
490 : :
491 [ + + + - : 23316 : TAILQ_FOREACH(tgt, &g_nvmf_tgts, link) {
+ - + - ]
492 [ + + ]: 11664 : if (name) {
493 [ - + - + : 24 : if (!strncmp(tgt->name, name, NVMF_TGT_NAME_MAX_LENGTH)) {
+ + # # ]
494 : 6 : return tgt;
495 : : }
496 : 0 : }
497 : 11658 : num_targets++;
498 : 191 : }
499 : :
500 : : /*
501 : : * special case. If there is only one target and
502 : : * no name was specified, return the only available
503 : : * target. If there is more than one target, name must
504 : : * be specified.
505 : : */
506 [ + + + + ]: 11652 : if (!name && num_targets == 1) {
507 : 11640 : return TAILQ_FIRST(&g_nvmf_tgts);
508 : : }
509 : :
510 : 12 : return NULL;
511 : 191 : }
512 : :
513 : : struct spdk_nvmf_tgt *
514 : 9 : spdk_nvmf_get_first_tgt(void)
515 : : {
516 : 9 : return TAILQ_FIRST(&g_nvmf_tgts);
517 : : }
518 : :
519 : : struct spdk_nvmf_tgt *
520 : 15 : spdk_nvmf_get_next_tgt(struct spdk_nvmf_tgt *prev)
521 : : {
522 [ # # # # : 15 : return TAILQ_NEXT(prev, link);
# # ]
523 : : }
524 : :
525 : : static void
526 : 23 : nvmf_write_nvme_subsystem_config(struct spdk_json_write_ctx *w,
527 : : struct spdk_nvmf_subsystem *subsystem)
528 : : {
529 : : struct spdk_nvmf_host *host;
530 : : struct spdk_nvmf_ns *ns;
531 : 1 : struct spdk_nvmf_ns_opts ns_opts;
532 : : uint32_t max_namespaces;
533 : : struct spdk_nvmf_transport *transport;
534 : :
535 [ - + # # ]: 23 : assert(spdk_nvmf_subsystem_get_type(subsystem) == SPDK_NVMF_SUBTYPE_NVME);
536 : :
537 : : /* { */
538 : 23 : spdk_json_write_object_begin(w);
539 : 23 : spdk_json_write_named_string(w, "method", "nvmf_create_subsystem");
540 : :
541 : : /* "params" : { */
542 : 23 : spdk_json_write_named_object_begin(w, "params");
543 : 23 : spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem));
544 : 23 : spdk_json_write_named_bool(w, "allow_any_host", spdk_nvmf_subsystem_get_allow_any_host(subsystem));
545 : 23 : spdk_json_write_named_string(w, "serial_number", spdk_nvmf_subsystem_get_sn(subsystem));
546 : 23 : spdk_json_write_named_string(w, "model_number", spdk_nvmf_subsystem_get_mn(subsystem));
547 : :
548 : 23 : max_namespaces = spdk_nvmf_subsystem_get_max_namespaces(subsystem);
549 [ + - ]: 23 : if (max_namespaces != 0) {
550 : 23 : spdk_json_write_named_uint32(w, "max_namespaces", max_namespaces);
551 : 0 : }
552 : :
553 : 23 : spdk_json_write_named_uint32(w, "min_cntlid", spdk_nvmf_subsystem_get_min_cntlid(subsystem));
554 : 23 : spdk_json_write_named_uint32(w, "max_cntlid", spdk_nvmf_subsystem_get_max_cntlid(subsystem));
555 : 23 : spdk_json_write_named_bool(w, "ana_reporting", spdk_nvmf_subsystem_get_ana_reporting(subsystem));
556 : :
557 : : /* } "params" */
558 : 23 : spdk_json_write_object_end(w);
559 : :
560 : : /* } */
561 : 23 : spdk_json_write_object_end(w);
562 : :
563 [ + + ]: 29 : for (host = spdk_nvmf_subsystem_get_first_host(subsystem); host != NULL;
564 : 6 : host = spdk_nvmf_subsystem_get_next_host(subsystem, host)) {
565 : :
566 : 6 : spdk_json_write_object_begin(w);
567 : 6 : spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_host");
568 : :
569 : : /* "params" : { */
570 : 6 : spdk_json_write_named_object_begin(w, "params");
571 : :
572 : 6 : spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem));
573 : 6 : spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host));
574 [ - + # # : 6 : if (host->dhchap_key != NULL) {
# # ]
575 : 0 : spdk_json_write_named_string(w, "dhchap_key",
576 [ # # # # ]: 0 : spdk_key_get_name(host->dhchap_key));
577 : 0 : }
578 [ - + # # : 6 : if (host->dhchap_ctrlr_key != NULL) {
# # ]
579 : 0 : spdk_json_write_named_string(w, "dhchap_ctrlr_key",
580 [ # # # # ]: 0 : spdk_key_get_name(host->dhchap_ctrlr_key));
581 : 0 : }
582 [ + + # # : 12 : TAILQ_FOREACH(transport, &subsystem->tgt->transports, link) {
# # # # #
# # # # #
# # # # ]
583 [ + - # # : 6 : if (transport->ops->subsystem_dump_host != NULL) {
# # # # ]
584 [ # # # # : 6 : transport->ops->subsystem_dump_host(transport, subsystem, host->nqn, w);
# # # # #
# # # ]
585 : 0 : }
586 : 0 : }
587 : :
588 : : /* } "params" */
589 : 6 : spdk_json_write_object_end(w);
590 : :
591 : : /* } */
592 : 6 : spdk_json_write_object_end(w);
593 : 0 : }
594 : :
595 [ + + ]: 62 : for (ns = spdk_nvmf_subsystem_get_first_ns(subsystem); ns != NULL;
596 : 39 : ns = spdk_nvmf_subsystem_get_next_ns(subsystem, ns)) {
597 : 39 : spdk_nvmf_ns_get_opts(ns, &ns_opts, sizeof(ns_opts));
598 : :
599 : 39 : spdk_json_write_object_begin(w);
600 : 39 : spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_ns");
601 : :
602 : : /* "params" : { */
603 : 39 : spdk_json_write_named_object_begin(w, "params");
604 : :
605 : 39 : spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem));
606 : :
607 : : /* "namespace" : { */
608 : 39 : spdk_json_write_named_object_begin(w, "namespace");
609 : :
610 : 39 : spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns));
611 : 39 : spdk_json_write_named_string(w, "bdev_name", spdk_bdev_get_name(spdk_nvmf_ns_get_bdev(ns)));
612 : :
613 [ - + # # : 39 : if (ns->ptpl_file != NULL) {
# # ]
614 [ # # # # ]: 0 : spdk_json_write_named_string(w, "ptpl_file", ns->ptpl_file);
615 : 0 : }
616 : :
617 [ + - ]: 39 : if (!spdk_mem_all_zero(ns_opts.nguid, sizeof(ns_opts.nguid))) {
618 : : SPDK_STATIC_ASSERT(sizeof(ns_opts.nguid) == sizeof(uint64_t) * 2, "size mismatch");
619 [ # # # # ]: 39 : spdk_json_write_named_string_fmt(w, "nguid", "%016"PRIX64"%016"PRIX64, from_be64(&ns_opts.nguid[0]),
620 [ # # # # ]: 0 : from_be64(&ns_opts.nguid[8]));
621 : 0 : }
622 : :
623 [ - + ]: 39 : if (!spdk_mem_all_zero(ns_opts.eui64, sizeof(ns_opts.eui64))) {
624 : : SPDK_STATIC_ASSERT(sizeof(ns_opts.eui64) == sizeof(uint64_t), "size mismatch");
625 : 0 : spdk_json_write_named_string_fmt(w, "eui64", "%016"PRIX64, from_be64(&ns_opts.eui64));
626 : 0 : }
627 : :
628 [ + - ]: 39 : if (!spdk_uuid_is_null(&ns_opts.uuid)) {
629 : 39 : spdk_json_write_named_uuid(w, "uuid", &ns_opts.uuid);
630 : 0 : }
631 : :
632 [ - + ]: 39 : if (spdk_nvmf_subsystem_get_ana_reporting(subsystem)) {
633 : 0 : spdk_json_write_named_uint32(w, "anagrpid", ns_opts.anagrpid);
634 : 0 : }
635 : :
636 [ - + # # : 39 : spdk_json_write_named_bool(w, "no_auto_visible", !ns->always_visible);
# # ]
637 : :
638 : : /* "namespace" */
639 : 39 : spdk_json_write_object_end(w);
640 : :
641 : : /* } "params" */
642 : 39 : spdk_json_write_object_end(w);
643 : :
644 : : /* } */
645 : 39 : spdk_json_write_object_end(w);
646 : :
647 [ - + # # : 39 : TAILQ_FOREACH(host, &ns->hosts, link) {
# # # # #
# # # #
# ]
648 : 0 : spdk_json_write_object_begin(w);
649 : 0 : spdk_json_write_named_string(w, "method", "nvmf_ns_add_host");
650 : 0 : spdk_json_write_named_object_begin(w, "params");
651 : 0 : spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem));
652 : 0 : spdk_json_write_named_uint32(w, "nsid", spdk_nvmf_ns_get_id(ns));
653 : 0 : spdk_json_write_named_string(w, "host", spdk_nvmf_host_get_nqn(host));
654 : 0 : spdk_json_write_object_end(w);
655 : 0 : spdk_json_write_object_end(w);
656 : 0 : }
657 : 0 : }
658 : 23 : }
659 : :
660 : : static void
661 : 138 : nvmf_write_subsystem_config_json(struct spdk_json_write_ctx *w,
662 : : struct spdk_nvmf_subsystem *subsystem)
663 : : {
664 : : struct spdk_nvmf_subsystem_listener *listener;
665 : : struct spdk_nvmf_transport *transport;
666 : : const struct spdk_nvme_transport_id *trid;
667 : :
668 [ + + ]: 138 : if (spdk_nvmf_subsystem_get_type(subsystem) == SPDK_NVMF_SUBTYPE_NVME) {
669 : 23 : nvmf_write_nvme_subsystem_config(w, subsystem);
670 : 0 : }
671 : :
672 [ + + ]: 161 : for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL;
673 : 23 : listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) {
674 [ # # # # ]: 23 : transport = listener->transport;
675 : 23 : trid = spdk_nvmf_subsystem_listener_get_trid(listener);
676 : :
677 : 23 : spdk_json_write_object_begin(w);
678 : 23 : spdk_json_write_named_string(w, "method", "nvmf_subsystem_add_listener");
679 : :
680 : : /* "params" : { */
681 : 23 : spdk_json_write_named_object_begin(w, "params");
682 : :
683 : 23 : spdk_json_write_named_string(w, "nqn", spdk_nvmf_subsystem_get_nqn(subsystem));
684 : :
685 : 23 : spdk_json_write_named_object_begin(w, "listen_address");
686 : 23 : nvmf_transport_listen_dump_trid(trid, w);
687 : 23 : spdk_json_write_object_end(w);
688 [ - + # # : 23 : if (transport->ops->listen_dump_opts) {
# # # # #
# ]
689 [ # # # # : 0 : transport->ops->listen_dump_opts(transport, trid, w);
# # # # #
# # # ]
690 : 0 : }
691 : :
692 [ - + # # : 23 : spdk_json_write_named_bool(w, "secure_channel", listener->opts.secure_channel);
# # # # ]
693 : :
694 [ + + # # : 23 : if (listener->opts.sock_impl) {
# # # # ]
695 [ # # # # : 3 : spdk_json_write_named_string(w, "sock_impl", listener->opts.sock_impl);
# # ]
696 : 0 : }
697 : :
698 : : /* } "params" */
699 : 23 : spdk_json_write_object_end(w);
700 : :
701 : : /* } */
702 : 23 : spdk_json_write_object_end(w);
703 : 0 : }
704 : 138 : }
705 : :
706 : : void
707 : 115 : spdk_nvmf_tgt_write_config_json(struct spdk_json_write_ctx *w, struct spdk_nvmf_tgt *tgt)
708 : : {
709 : : struct spdk_nvmf_subsystem *subsystem;
710 : : struct spdk_nvmf_transport *transport;
711 : : struct spdk_nvmf_referral *referral;
712 : :
713 : 115 : spdk_json_write_object_begin(w);
714 : 115 : spdk_json_write_named_string(w, "method", "nvmf_set_max_subsystems");
715 : :
716 : 115 : spdk_json_write_named_object_begin(w, "params");
717 [ + - + - ]: 115 : spdk_json_write_named_uint32(w, "max_subsystems", tgt->max_subsystems);
718 : 115 : spdk_json_write_object_end(w);
719 : :
720 : 115 : spdk_json_write_object_end(w);
721 : :
722 : 115 : spdk_json_write_object_begin(w);
723 : 115 : spdk_json_write_named_string(w, "method", "nvmf_set_crdt");
724 : 115 : spdk_json_write_named_object_begin(w, "params");
725 [ + - + - : 115 : spdk_json_write_named_uint32(w, "crdt1", tgt->crdt[0]);
+ - + - ]
726 [ + - + - : 115 : spdk_json_write_named_uint32(w, "crdt2", tgt->crdt[1]);
+ - + - ]
727 [ + - + - : 115 : spdk_json_write_named_uint32(w, "crdt3", tgt->crdt[2]);
+ - + - ]
728 : 115 : spdk_json_write_object_end(w);
729 : 115 : spdk_json_write_object_end(w);
730 : :
731 : : /* write transports */
732 [ + + + - : 164 : TAILQ_FOREACH(transport, &tgt->transports, link) {
+ - + + +
- + - +
- ]
733 : 49 : spdk_json_write_object_begin(w);
734 : 49 : spdk_json_write_named_string(w, "method", "nvmf_create_transport");
735 : 49 : nvmf_transport_dump_opts(transport, w, true);
736 : 49 : spdk_json_write_object_end(w);
737 : 2 : }
738 : :
739 [ + + + - : 115 : TAILQ_FOREACH(referral, &tgt->referrals, link) {
+ - - + #
# # # #
# ]
740 : 0 : spdk_json_write_object_begin(w);
741 : 0 : spdk_json_write_named_string(w, "method", "nvmf_discovery_add_referral");
742 : :
743 : 0 : spdk_json_write_named_object_begin(w, "params");
744 : 0 : spdk_json_write_named_object_begin(w, "address");
745 [ # # ]: 0 : nvmf_transport_listen_dump_trid(&referral->trid, w);
746 : 0 : spdk_json_write_object_end(w);
747 : 0 : spdk_json_write_named_bool(w, "secure_channel",
748 [ # # # # : 0 : referral->entry.treq.secure_channel ==
# # ]
749 : : SPDK_NVMF_TREQ_SECURE_CHANNEL_REQUIRED);
750 [ # # # # ]: 0 : spdk_json_write_named_string(w, "subnqn", referral->trid.subnqn);
751 : 0 : spdk_json_write_object_end(w);
752 : :
753 : 0 : spdk_json_write_object_end(w);
754 : 0 : }
755 : :
756 : 115 : subsystem = spdk_nvmf_subsystem_get_first(tgt);
757 [ + + ]: 253 : while (subsystem) {
758 : 138 : nvmf_write_subsystem_config_json(w, subsystem);
759 : 138 : subsystem = spdk_nvmf_subsystem_get_next(subsystem);
760 : : }
761 : 115 : }
762 : :
763 : : static void
764 : 1199 : nvmf_listen_opts_copy(struct spdk_nvmf_listen_opts *opts,
765 : : const struct spdk_nvmf_listen_opts *opts_src, size_t opts_size)
766 : : {
767 [ + + # # ]: 1199 : assert(opts);
768 [ + + # # ]: 1199 : assert(opts_src);
769 : :
770 [ + - + - ]: 1199 : opts->opts_size = opts_size;
771 : :
772 : : #define SET_FIELD(field) \
773 : : if (offsetof(struct spdk_nvmf_listen_opts, field) + sizeof(opts->field) <= opts_size) { \
774 : : opts->field = opts_src->field; \
775 : : } \
776 : :
777 [ + + + - : 1199 : SET_FIELD(transport_specific);
+ - + - +
- ]
778 [ + + + + : 1199 : SET_FIELD(secure_channel);
+ - + - +
- + - ]
779 [ + + + - : 1199 : SET_FIELD(ana_state);
+ - + - +
- ]
780 [ + + + - : 1199 : SET_FIELD(sock_impl);
+ - + - +
- ]
781 : : #undef SET_FIELD
782 : :
783 : : /* Do not remove this statement, you should always update this statement when you adding a new field,
784 : : * and do not forget to add the SET_FIELD statement for your added field. */
785 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_nvmf_listen_opts) == 32, "Incorrect size");
786 : 1199 : }
787 : :
788 : : void
789 : 601 : spdk_nvmf_listen_opts_init(struct spdk_nvmf_listen_opts *opts, size_t opts_size)
790 : : {
791 : 601 : struct spdk_nvmf_listen_opts opts_local = {};
792 : :
793 : : /* local version of opts should have defaults set here */
794 : 601 : opts_local.ana_state = SPDK_NVME_ANA_OPTIMIZED_STATE;
795 : 601 : nvmf_listen_opts_copy(opts, &opts_local, opts_size);
796 : 601 : }
797 : :
798 : : int
799 : 598 : spdk_nvmf_tgt_listen_ext(struct spdk_nvmf_tgt *tgt, const struct spdk_nvme_transport_id *trid,
800 : : struct spdk_nvmf_listen_opts *opts)
801 : : {
802 : : struct spdk_nvmf_transport *transport;
803 : : int rc;
804 : 598 : struct spdk_nvmf_listen_opts opts_local = {};
805 : :
806 [ + + ]: 598 : if (!opts) {
807 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
808 : 0 : return -EINVAL;
809 : : }
810 : :
811 [ + + + - : 598 : if (!opts->opts_size) {
+ - ]
812 : 0 : SPDK_ERRLOG("The opts_size in opts structure should not be zero\n");
813 : 0 : return -EINVAL;
814 : : }
815 : :
816 [ + - ]: 598 : transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring);
817 [ + + ]: 598 : if (!transport) {
818 [ # # ]: 0 : SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n",
819 : : trid->trstring);
820 : 0 : return -EINVAL;
821 : : }
822 : :
823 [ + - + - ]: 598 : nvmf_listen_opts_copy(&opts_local, opts, opts->opts_size);
824 : 598 : rc = spdk_nvmf_transport_listen(transport, trid, &opts_local);
825 [ + + ]: 598 : if (rc < 0) {
826 [ # # ]: 0 : SPDK_ERRLOG("Unable to listen on address '%s'\n", trid->traddr);
827 : 0 : }
828 : :
829 : 598 : return rc;
830 : 39 : }
831 : :
832 : : int
833 : 0 : spdk_nvmf_tgt_stop_listen(struct spdk_nvmf_tgt *tgt,
834 : : struct spdk_nvme_transport_id *trid)
835 : : {
836 : : struct spdk_nvmf_transport *transport;
837 : : int rc;
838 : :
839 [ # # ]: 0 : transport = spdk_nvmf_tgt_get_transport(tgt, trid->trstring);
840 [ # # ]: 0 : if (!transport) {
841 [ # # ]: 0 : SPDK_ERRLOG("Unable to find %s transport. The transport must be created first also make sure it is properly registered.\n",
842 : : trid->trstring);
843 : 0 : return -EINVAL;
844 : : }
845 : :
846 : 0 : rc = spdk_nvmf_transport_stop_listen(transport, trid);
847 [ # # ]: 0 : if (rc < 0) {
848 [ # # ]: 0 : SPDK_ERRLOG("Failed to stop listening on address '%s'\n", trid->traddr);
849 : 0 : return rc;
850 : : }
851 : 0 : return 0;
852 : 0 : }
853 : :
854 : : struct spdk_nvmf_tgt_add_transport_ctx {
855 : : struct spdk_nvmf_tgt *tgt;
856 : : struct spdk_nvmf_transport *transport;
857 : : spdk_nvmf_tgt_add_transport_done_fn cb_fn;
858 : : void *cb_arg;
859 : : int status;
860 : : };
861 : :
862 : : static void
863 : 0 : _nvmf_tgt_remove_transport_done(struct spdk_io_channel_iter *i, int status)
864 : : {
865 : 0 : struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
866 : :
867 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, ctx->status);
# # # # #
# # # # #
# # ]
868 : 0 : free(ctx);
869 : 0 : }
870 : :
871 : : static void
872 : 0 : _nvmf_tgt_remove_transport(struct spdk_io_channel_iter *i)
873 : : {
874 : 0 : struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
875 : 0 : struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i);
876 : 0 : struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch);
877 : : struct spdk_nvmf_transport_poll_group *tgroup, *tmp;
878 : :
879 [ # # # # : 0 : TAILQ_FOREACH_SAFE(tgroup, &group->tgroups, link, tmp) {
# # # # #
# # # # #
# # ]
880 [ # # # # : 0 : if (tgroup->transport == ctx->transport) {
# # # # #
# ]
881 [ # # # # : 0 : TAILQ_REMOVE(&group->tgroups, tgroup, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
882 : 0 : nvmf_transport_poll_group_destroy(tgroup);
883 : 0 : }
884 : 0 : }
885 : :
886 : 0 : spdk_for_each_channel_continue(i, 0);
887 : 0 : }
888 : :
889 : : static void
890 : 335 : _nvmf_tgt_add_transport_done(struct spdk_io_channel_iter *i, int status)
891 : : {
892 : 335 : struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
893 : :
894 [ - + ]: 335 : if (status) {
895 [ # # # # ]: 0 : ctx->status = status;
896 [ # # # # ]: 0 : spdk_for_each_channel(ctx->tgt,
897 : : _nvmf_tgt_remove_transport,
898 : 0 : ctx,
899 : : _nvmf_tgt_remove_transport_done);
900 : 0 : return;
901 : : }
902 : :
903 [ + - + - : 335 : ctx->transport->tgt = ctx->tgt;
+ - + - +
- + - ]
904 [ + - + - : 335 : TAILQ_INSERT_TAIL(&ctx->tgt->transports, ctx->transport, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - +
- ]
905 [ + - + - : 335 : ctx->cb_fn(ctx->cb_arg, status);
- + + - +
- + - ]
906 : 335 : free(ctx);
907 : 36 : }
908 : :
909 : : static void
910 : 707 : _nvmf_tgt_add_transport(struct spdk_io_channel_iter *i)
911 : : {
912 : 707 : struct spdk_nvmf_tgt_add_transport_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
913 : 707 : struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i);
914 : 707 : struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch);
915 : : int rc;
916 : :
917 [ + - + - ]: 707 : rc = nvmf_poll_group_add_transport(group, ctx->transport);
918 : 707 : spdk_for_each_channel_continue(i, rc);
919 : 707 : }
920 : :
921 : : void
922 : 335 : spdk_nvmf_tgt_add_transport(struct spdk_nvmf_tgt *tgt,
923 : : struct spdk_nvmf_transport *transport,
924 : : spdk_nvmf_tgt_add_transport_done_fn cb_fn,
925 : : void *cb_arg)
926 : : {
927 : : struct spdk_nvmf_tgt_add_transport_ctx *ctx;
928 : :
929 : 121 : SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_add_transport, transport, tgt->name);
930 : :
931 [ + + + - : 335 : if (spdk_nvmf_tgt_get_transport(tgt, transport->ops->name)) {
+ - - + ]
932 [ # # # # ]: 0 : cb_fn(cb_arg, -EEXIST);
933 : 0 : return; /* transport already created */
934 : : }
935 : :
936 : 335 : ctx = calloc(1, sizeof(*ctx));
937 [ - + ]: 335 : if (!ctx) {
938 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
939 : 0 : return;
940 : : }
941 : :
942 [ + - + - ]: 335 : ctx->tgt = tgt;
943 [ + - + - ]: 335 : ctx->transport = transport;
944 [ + - + - ]: 335 : ctx->cb_fn = cb_fn;
945 [ + - + - ]: 335 : ctx->cb_arg = cb_arg;
946 : :
947 : 371 : spdk_for_each_channel(tgt,
948 : : _nvmf_tgt_add_transport,
949 : 36 : ctx,
950 : : _nvmf_tgt_add_transport_done);
951 : 36 : }
952 : :
953 : : struct nvmf_tgt_pause_ctx {
954 : : struct spdk_nvmf_tgt *tgt;
955 : : spdk_nvmf_tgt_pause_polling_cb_fn cb_fn;
956 : : void *cb_arg;
957 : : };
958 : :
959 : : static void
960 : 0 : _nvmf_tgt_pause_polling_done(struct spdk_io_channel_iter *i, int status)
961 : : {
962 : 0 : struct nvmf_tgt_pause_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
963 : :
964 [ # # # # : 0 : ctx->tgt->state = NVMF_TGT_PAUSED;
# # # # ]
965 : :
966 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, status);
# # # # #
# # # ]
967 : 0 : free(ctx);
968 : 0 : }
969 : :
970 : : static void
971 : 0 : _nvmf_tgt_pause_polling(struct spdk_io_channel_iter *i)
972 : : {
973 : 0 : struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i);
974 : 0 : struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch);
975 : : struct spdk_nvmf_transport_poll_group *tgroup;
976 : :
977 [ # # # # : 0 : TAILQ_FOREACH(tgroup, &group->tgroups, link) {
# # # # #
# # # #
# ]
978 : 0 : nvmf_transport_poll_group_pause(tgroup);
979 : 0 : }
980 : :
981 : 0 : spdk_for_each_channel_continue(i, 0);
982 : 0 : }
983 : :
984 : : int
985 : 0 : spdk_nvmf_tgt_pause_polling(struct spdk_nvmf_tgt *tgt, spdk_nvmf_tgt_pause_polling_cb_fn cb_fn,
986 : : void *cb_arg)
987 : : {
988 : : struct nvmf_tgt_pause_ctx *ctx;
989 : :
990 : 0 : SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_pause_polling, tgt, tgt->name);
991 : :
992 [ # # # # : 0 : switch (tgt->state) {
# # # ]
993 : 0 : case NVMF_TGT_PAUSING:
994 : : case NVMF_TGT_RESUMING:
995 : 0 : return -EBUSY;
996 : 0 : case NVMF_TGT_RUNNING:
997 : 0 : break;
998 : 0 : default:
999 : 0 : return -EINVAL;
1000 : : }
1001 : :
1002 : 0 : ctx = calloc(1, sizeof(*ctx));
1003 [ # # ]: 0 : if (!ctx) {
1004 : 0 : return -ENOMEM;
1005 : : }
1006 : :
1007 : :
1008 [ # # # # ]: 0 : tgt->state = NVMF_TGT_PAUSING;
1009 : :
1010 [ # # # # ]: 0 : ctx->tgt = tgt;
1011 [ # # # # ]: 0 : ctx->cb_fn = cb_fn;
1012 [ # # # # ]: 0 : ctx->cb_arg = cb_arg;
1013 : :
1014 : 0 : spdk_for_each_channel(tgt,
1015 : : _nvmf_tgt_pause_polling,
1016 : 0 : ctx,
1017 : : _nvmf_tgt_pause_polling_done);
1018 : 0 : return 0;
1019 : 0 : }
1020 : :
1021 : : static void
1022 : 0 : _nvmf_tgt_resume_polling_done(struct spdk_io_channel_iter *i, int status)
1023 : : {
1024 : 0 : struct nvmf_tgt_pause_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
1025 : :
1026 [ # # # # : 0 : ctx->tgt->state = NVMF_TGT_RUNNING;
# # # # ]
1027 : :
1028 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, status);
# # # # #
# # # ]
1029 : 0 : free(ctx);
1030 : 0 : }
1031 : :
1032 : : static void
1033 : 0 : _nvmf_tgt_resume_polling(struct spdk_io_channel_iter *i)
1034 : : {
1035 : 0 : struct spdk_io_channel *ch = spdk_io_channel_iter_get_channel(i);
1036 : 0 : struct spdk_nvmf_poll_group *group = spdk_io_channel_get_ctx(ch);
1037 : : struct spdk_nvmf_transport_poll_group *tgroup;
1038 : :
1039 [ # # # # : 0 : TAILQ_FOREACH(tgroup, &group->tgroups, link) {
# # # # #
# # # #
# ]
1040 : 0 : nvmf_transport_poll_group_resume(tgroup);
1041 : 0 : }
1042 : :
1043 : 0 : spdk_for_each_channel_continue(i, 0);
1044 : 0 : }
1045 : :
1046 : : int
1047 : 0 : spdk_nvmf_tgt_resume_polling(struct spdk_nvmf_tgt *tgt, spdk_nvmf_tgt_resume_polling_cb_fn cb_fn,
1048 : : void *cb_arg)
1049 : : {
1050 : : struct nvmf_tgt_pause_ctx *ctx;
1051 : :
1052 : 0 : SPDK_DTRACE_PROBE2_TICKS(nvmf_tgt_resume_polling, tgt, tgt->name);
1053 : :
1054 [ # # # # : 0 : switch (tgt->state) {
# # # ]
1055 : 0 : case NVMF_TGT_PAUSING:
1056 : : case NVMF_TGT_RESUMING:
1057 : 0 : return -EBUSY;
1058 : 0 : case NVMF_TGT_PAUSED:
1059 : 0 : break;
1060 : 0 : default:
1061 : 0 : return -EINVAL;
1062 : : }
1063 : :
1064 : 0 : ctx = calloc(1, sizeof(*ctx));
1065 [ # # ]: 0 : if (!ctx) {
1066 : 0 : return -ENOMEM;
1067 : : }
1068 : :
1069 [ # # # # ]: 0 : tgt->state = NVMF_TGT_RESUMING;
1070 : :
1071 [ # # # # ]: 0 : ctx->tgt = tgt;
1072 [ # # # # ]: 0 : ctx->cb_fn = cb_fn;
1073 [ # # # # ]: 0 : ctx->cb_arg = cb_arg;
1074 : :
1075 : 0 : spdk_for_each_channel(tgt,
1076 : : _nvmf_tgt_resume_polling,
1077 : 0 : ctx,
1078 : : _nvmf_tgt_resume_polling_done);
1079 : 0 : return 0;
1080 : 0 : }
1081 : :
1082 : : struct spdk_nvmf_subsystem *
1083 : 53743 : spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn)
1084 : : {
1085 : 1047 : struct spdk_nvmf_subsystem subsystem;
1086 : :
1087 [ + + ]: 53743 : if (!subnqn) {
1088 : 0 : return NULL;
1089 : : }
1090 : :
1091 : : /* Ensure that subnqn is null terminated */
1092 [ + + + + ]: 53743 : if (!memchr(subnqn, '\0', SPDK_NVMF_NQN_MAX_LEN + 1)) {
1093 : 0 : SPDK_ERRLOG("Connect SUBNQN is not null terminated\n");
1094 : 0 : return NULL;
1095 : : }
1096 : :
1097 : 53743 : snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn);
1098 [ + - ]: 53743 : return RB_FIND(subsystem_tree, &tgt->subsystems, &subsystem);
1099 : 6354 : }
1100 : :
1101 : : struct spdk_nvmf_transport *
1102 : 2491 : spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name)
1103 : : {
1104 : : struct spdk_nvmf_transport *transport;
1105 : :
1106 [ + + + - : 2491 : TAILQ_FOREACH(transport, &tgt->transports, link) {
+ - + + #
# # # #
# ]
1107 [ + + + + : 1799 : if (!strncasecmp(transport->ops->name, transport_name, SPDK_NVMF_TRSTRING_MAX_LEN)) {
+ - + - +
- - + ]
1108 : 1799 : return transport;
1109 : : }
1110 : 0 : }
1111 : 692 : return NULL;
1112 : 191 : }
1113 : :
1114 : : struct nvmf_new_qpair_ctx {
1115 : : struct spdk_nvmf_qpair *qpair;
1116 : : struct spdk_nvmf_poll_group *group;
1117 : : };
1118 : :
1119 : : static void
1120 : 10725 : _nvmf_poll_group_add(void *_ctx)
1121 : : {
1122 : 10725 : struct nvmf_new_qpair_ctx *ctx = _ctx;
1123 [ + - + - ]: 10725 : struct spdk_nvmf_qpair *qpair = ctx->qpair;
1124 [ + - + - ]: 10725 : struct spdk_nvmf_poll_group *group = ctx->group;
1125 : :
1126 : 10725 : free(_ctx);
1127 : :
1128 [ + + ]: 10725 : if (spdk_nvmf_poll_group_add(group, qpair) != 0) {
1129 : 0 : SPDK_ERRLOG("Unable to add the qpair to a poll group.\n");
1130 : :
1131 [ # # # # : 0 : assert(qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED);
# # # # ]
1132 [ # # # # ]: 0 : pthread_mutex_lock(&group->mutex);
1133 [ # # # # : 0 : assert(group->current_unassociated_qpairs > 0);
# # # # ]
1134 [ # # ]: 0 : group->current_unassociated_qpairs--;
1135 [ # # # # ]: 0 : pthread_mutex_unlock(&group->mutex);
1136 : :
1137 : 0 : spdk_nvmf_qpair_disconnect(qpair);
1138 : 0 : }
1139 : 10725 : }
1140 : :
1141 : : void
1142 : 10725 : spdk_nvmf_tgt_new_qpair(struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair)
1143 : : {
1144 : : struct spdk_nvmf_poll_group *group;
1145 : : struct nvmf_new_qpair_ctx *ctx;
1146 : :
1147 : 10725 : group = spdk_nvmf_get_optimal_poll_group(qpair);
1148 [ + + ]: 10725 : if (group == NULL) {
1149 [ # # # # : 0 : if (tgt->next_poll_group == NULL) {
# # ]
1150 [ # # # # : 0 : tgt->next_poll_group = TAILQ_FIRST(&tgt->poll_groups);
# # # # #
# ]
1151 [ # # # # : 0 : if (tgt->next_poll_group == NULL) {
# # ]
1152 : 0 : SPDK_ERRLOG("No poll groups exist.\n");
1153 : 0 : spdk_nvmf_qpair_disconnect(qpair);
1154 : 0 : return;
1155 : : }
1156 : 0 : }
1157 [ # # # # ]: 0 : group = tgt->next_poll_group;
1158 [ # # # # : 0 : tgt->next_poll_group = TAILQ_NEXT(group, link);
# # # # #
# ]
1159 : 0 : }
1160 : :
1161 : 10725 : ctx = calloc(1, sizeof(*ctx));
1162 [ + + ]: 10725 : if (!ctx) {
1163 : 0 : SPDK_ERRLOG("Unable to send message to poll group.\n");
1164 : 0 : spdk_nvmf_qpair_disconnect(qpair);
1165 : 0 : return;
1166 : : }
1167 : :
1168 [ + - + - ]: 10725 : ctx->qpair = qpair;
1169 [ + - + - ]: 10725 : ctx->group = group;
1170 : :
1171 [ + + + - ]: 10725 : pthread_mutex_lock(&group->mutex);
1172 [ + - ]: 10725 : group->current_unassociated_qpairs++;
1173 [ + + + - ]: 10725 : pthread_mutex_unlock(&group->mutex);
1174 : :
1175 [ + - + - ]: 10725 : spdk_thread_send_msg(group->thread, _nvmf_poll_group_add, ctx);
1176 : 1749 : }
1177 : :
1178 : : struct spdk_nvmf_poll_group *
1179 : 1493 : spdk_nvmf_poll_group_create(struct spdk_nvmf_tgt *tgt)
1180 : : {
1181 : : struct spdk_io_channel *ch;
1182 : :
1183 : 1493 : ch = spdk_get_io_channel(tgt);
1184 [ - + ]: 1493 : if (!ch) {
1185 : 0 : SPDK_ERRLOG("Unable to get I/O channel for target\n");
1186 : 0 : return NULL;
1187 : : }
1188 : :
1189 : 1493 : return spdk_io_channel_get_ctx(ch);
1190 : 82 : }
1191 : :
1192 : : void
1193 : 1492 : spdk_nvmf_poll_group_destroy(struct spdk_nvmf_poll_group *group,
1194 : : spdk_nvmf_poll_group_destroy_done_fn cb_fn,
1195 : : void *cb_arg)
1196 : : {
1197 [ + + + - : 1492 : assert(group->destroy_cb_fn == NULL);
+ - # # ]
1198 [ + - + - ]: 1492 : group->destroy_cb_fn = cb_fn;
1199 [ + - + - ]: 1492 : group->destroy_cb_arg = cb_arg;
1200 : :
1201 : : /* This function will put the io_channel associated with this poll group */
1202 : 1492 : nvmf_tgt_destroy_poll_group_qpairs(group);
1203 : 1492 : }
1204 : :
1205 : : int
1206 : 10725 : spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group,
1207 : : struct spdk_nvmf_qpair *qpair)
1208 : : {
1209 : : int rc;
1210 : : struct spdk_nvmf_transport_poll_group *tgroup;
1211 : :
1212 [ + - + - : 10725 : TAILQ_INIT(&qpair->outstanding);
+ - + - +
- + - + -
+ - ]
1213 [ + - + - ]: 10725 : qpair->group = group;
1214 [ + - + - ]: 10725 : qpair->ctrlr = NULL;
1215 [ + - + - ]: 10725 : qpair->disconnect_started = false;
1216 : :
1217 [ + - + - ]: 10725 : tgroup = nvmf_get_transport_poll_group(group, qpair->transport);
1218 [ + + ]: 10725 : if (tgroup == NULL) {
1219 : 0 : return -1;
1220 : : }
1221 : :
1222 : 10725 : rc = nvmf_transport_poll_group_add(tgroup, qpair);
1223 : :
1224 : : /* We add the qpair to the group only it is successfully added into the tgroup */
1225 [ + - ]: 10725 : if (rc == 0) {
1226 : 2571 : SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_add_qpair, qpair, spdk_thread_get_id(group->thread));
1227 [ + - + - : 10725 : TAILQ_INSERT_TAIL(&group->qpairs, qpair, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
1228 : 10725 : nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_CONNECTING);
1229 : 1749 : }
1230 : :
1231 : 10725 : return rc;
1232 : 1749 : }
1233 : :
1234 : : static void
1235 : 2716 : _nvmf_ctrlr_destruct(void *ctx)
1236 : : {
1237 : 2716 : struct spdk_nvmf_ctrlr *ctrlr = ctx;
1238 : :
1239 : 2716 : nvmf_ctrlr_destruct(ctrlr);
1240 : 2716 : }
1241 : :
1242 : : static void
1243 : 10175 : _nvmf_ctrlr_free_from_qpair(void *ctx)
1244 : : {
1245 : 10175 : struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx;
1246 [ + - + - ]: 10175 : struct spdk_nvmf_ctrlr *ctrlr = qpair_ctx->ctrlr;
1247 : : uint32_t count;
1248 : :
1249 [ + - + - : 10175 : spdk_bit_array_clear(ctrlr->qpair_mask, qpair_ctx->qid);
+ - + - ]
1250 [ + + + + : 10175 : SPDK_DEBUGLOG(nvmf, "qpair_mask cleared, qid %u\n", qpair_ctx->qid);
+ - # # #
# ]
1251 [ + - + - ]: 10175 : count = spdk_bit_array_count_set(ctrlr->qpair_mask);
1252 [ + + ]: 10175 : if (count == 0) {
1253 [ + + + + : 2716 : assert(!ctrlr->in_destruct);
+ - + - #
# ]
1254 [ + + + + : 2716 : SPDK_DEBUGLOG(nvmf, "Last qpair %u, destroy ctrlr 0x%hx\n", qpair_ctx->qid, ctrlr->cntlid);
+ - # # #
# # # #
# ]
1255 [ + - + - ]: 2716 : ctrlr->in_destruct = true;
1256 [ + - + - : 2716 : spdk_thread_send_msg(ctrlr->subsys->thread, _nvmf_ctrlr_destruct, ctrlr);
+ - + - ]
1257 : 906 : }
1258 : 10175 : free(qpair_ctx);
1259 : 10175 : }
1260 : :
1261 : : static void
1262 : 10725 : _nvmf_transport_qpair_fini_complete(void *cb_ctx)
1263 : : {
1264 : 10725 : struct nvmf_qpair_disconnect_ctx *qpair_ctx = cb_ctx;
1265 : : struct spdk_nvmf_ctrlr *ctrlr;
1266 : :
1267 [ + - + - ]: 10725 : ctrlr = qpair_ctx->ctrlr;
1268 [ + + + + : 10725 : SPDK_DEBUGLOG(nvmf, "Finish destroying qid %u\n", qpair_ctx->qid);
+ - # # #
# ]
1269 : :
1270 [ + + ]: 10725 : if (ctrlr) {
1271 [ + + + - : 10175 : if (qpair_ctx->qid == 0) {
+ + ]
1272 : : /* Admin qpair is removed, so set the pointer to NULL.
1273 : : * This operation is safe since we are on ctrlr thread now, admin qpair's thread is the same
1274 : : * as controller's thread */
1275 [ + + + - : 2716 : assert(ctrlr->thread == spdk_get_thread());
+ - # # ]
1276 [ + - + - ]: 2716 : ctrlr->admin_qpair = NULL;
1277 : 906 : }
1278 : : /* Free qpair id from controller's bit mask and destroy the controller if it is the last qpair */
1279 [ + - + - : 10175 : if (ctrlr->thread) {
+ - ]
1280 [ + - + - ]: 10175 : spdk_thread_send_msg(ctrlr->thread, _nvmf_ctrlr_free_from_qpair, qpair_ctx);
1281 : 1749 : } else {
1282 : 0 : _nvmf_ctrlr_free_from_qpair(qpair_ctx);
1283 : : }
1284 : 1749 : } else {
1285 : 550 : free(qpair_ctx);
1286 : : }
1287 : 10725 : }
1288 : :
1289 : : void
1290 : 10725 : spdk_nvmf_poll_group_remove(struct spdk_nvmf_qpair *qpair)
1291 : : {
1292 : : struct spdk_nvmf_transport_poll_group *tgroup;
1293 : : int rc;
1294 : :
1295 : 2571 : SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_remove_qpair, qpair,
1296 : : spdk_thread_get_id(qpair->group->thread));
1297 : 10725 : nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_ERROR);
1298 : :
1299 : : /* Find the tgroup and remove the qpair from the tgroup */
1300 [ + - + - : 10725 : tgroup = nvmf_get_transport_poll_group(qpair->group, qpair->transport);
+ - + - ]
1301 [ + + ]: 10725 : if (tgroup != NULL) {
1302 : 10725 : rc = nvmf_transport_poll_group_remove(tgroup, qpair);
1303 [ - + - - ]: 10725 : if (rc && (rc != ENOTSUP)) {
1304 : 0 : SPDK_ERRLOG("Cannot remove qpair=%p from transport group=%p\n",
1305 : : qpair, tgroup);
1306 : 0 : }
1307 : 1749 : }
1308 : :
1309 [ + + + - : 10725 : TAILQ_REMOVE(&qpair->group->qpairs, qpair, link);
+ - + + +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - ]
1310 [ + - + - ]: 10725 : qpair->group = NULL;
1311 : 10725 : }
1312 : :
1313 : : static void
1314 : 573375 : _nvmf_qpair_sgroup_req_clean(struct spdk_nvmf_subsystem_poll_group *sgroup,
1315 : : const struct spdk_nvmf_qpair *qpair)
1316 : : {
1317 : : struct spdk_nvmf_request *req, *tmp;
1318 [ + + + - : 573375 : TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) {
+ - + - #
# # # # #
+ - ]
1319 [ # # # # : 0 : if (req->qpair == qpair) {
# # ]
1320 [ # # # # : 0 : TAILQ_REMOVE(&sgroup->queued, req, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
1321 [ # # ]: 0 : if (nvmf_transport_req_free(req)) {
1322 : 0 : SPDK_ERRLOG("Transport request free error!\n");
1323 : 0 : }
1324 : 0 : }
1325 : 0 : }
1326 : 573375 : }
1327 : :
1328 : : static void
1329 : 10725 : _nvmf_qpair_destroy(void *ctx, int status)
1330 : : {
1331 : 10725 : struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx;
1332 [ + - + - ]: 10725 : struct spdk_nvmf_qpair *qpair = qpair_ctx->qpair;
1333 [ + - + - ]: 10725 : struct spdk_nvmf_ctrlr *ctrlr = qpair->ctrlr;
1334 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1335 : : uint32_t sid;
1336 : :
1337 [ + + + - : 10725 : assert(qpair->state == SPDK_NVMF_QPAIR_DEACTIVATING);
+ - # # ]
1338 [ + - + - : 10725 : qpair_ctx->qid = qpair->qid;
+ - + - ]
1339 : :
1340 [ + + + + : 10725 : if (qpair->connect_received) {
+ - + - ]
1341 [ + + + - : 10703 : if (0 == qpair->qid) {
+ + ]
1342 [ - + - + : 2716 : assert(qpair->group->stat.current_admin_qpairs > 0);
- + - + -
+ + - #
# ]
1343 [ + - + - : 2716 : qpair->group->stat.current_admin_qpairs--;
+ - + - ]
1344 : 906 : } else {
1345 [ - + - + : 7987 : assert(qpair->group->stat.current_io_qpairs > 0);
- + - + -
+ + - #
# ]
1346 [ + - + - : 7987 : qpair->group->stat.current_io_qpairs--;
+ - + - ]
1347 : : }
1348 : 1749 : } else {
1349 [ - + # # : 22 : pthread_mutex_lock(&qpair->group->mutex);
# # # # ]
1350 [ - + # # : 22 : assert(qpair->group->current_unassociated_qpairs > 0);
# # # # #
# # # ]
1351 [ # # # # : 22 : qpair->group->current_unassociated_qpairs--;
# # ]
1352 [ - + # # : 22 : pthread_mutex_unlock(&qpair->group->mutex);
# # # # ]
1353 : : }
1354 : :
1355 [ + + ]: 10725 : if (ctrlr) {
1356 [ + - + - : 10175 : sgroup = &qpair->group->sgroups[ctrlr->subsys->id];
+ - + - +
- + - + -
+ - + - ]
1357 : 10175 : _nvmf_qpair_sgroup_req_clean(sgroup, qpair);
1358 : 1749 : } else {
1359 [ + + # # : 563750 : for (sid = 0; sid < qpair->group->num_sgroups; sid++) {
# # # # #
# ]
1360 [ # # # # : 563200 : sgroup = &qpair->group->sgroups[sid];
# # # # #
# ]
1361 [ - + # # ]: 563200 : assert(sgroup != NULL);
1362 : 563200 : _nvmf_qpair_sgroup_req_clean(sgroup, qpair);
1363 : 0 : }
1364 : : }
1365 : :
1366 : 10725 : nvmf_qpair_auth_destroy(qpair);
1367 [ + - + - ]: 10725 : qpair_ctx->ctrlr = ctrlr;
1368 : 10725 : spdk_nvmf_poll_group_remove(qpair);
1369 : 10725 : nvmf_transport_qpair_fini(qpair, _nvmf_transport_qpair_fini_complete, qpair_ctx);
1370 : 10725 : }
1371 : :
1372 : : static void
1373 : 1486 : _nvmf_qpair_disconnect_msg(void *ctx)
1374 : : {
1375 : 1486 : struct nvmf_qpair_disconnect_ctx *qpair_ctx = ctx;
1376 : :
1377 [ # # # # ]: 1486 : spdk_nvmf_qpair_disconnect(qpair_ctx->qpair);
1378 : 1486 : free(ctx);
1379 : 1486 : }
1380 : :
1381 : : int
1382 : 1789587 : spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair)
1383 : : {
1384 [ + - + - ]: 1789587 : struct spdk_nvmf_poll_group *group = qpair->group;
1385 : : struct nvmf_qpair_disconnect_ctx *qpair_ctx;
1386 : :
1387 [ + + - + ]: 1789587 : if (__atomic_test_and_set(&qpair->disconnect_started, __ATOMIC_RELAXED)) {
1388 : 1777376 : return -EINPROGRESS;
1389 : : }
1390 : :
1391 : : /* If we get a qpair in the uninitialized state, we can just destroy it immediately */
1392 [ + + + - : 12211 : if (qpair->state == SPDK_NVMF_QPAIR_UNINITIALIZED) {
+ - ]
1393 : 0 : nvmf_transport_qpair_fini(qpair, NULL, NULL);
1394 : 0 : return 0;
1395 : : }
1396 : :
1397 [ + + # # ]: 12211 : assert(group != NULL);
1398 [ + + + - : 12211 : if (spdk_get_thread() != group->thread) {
- + ]
1399 : : /* clear the atomic so we can set it on the next call on the proper thread. */
1400 [ # # ]: 1486 : __atomic_clear(&qpair->disconnect_started, __ATOMIC_RELAXED);
1401 : 1486 : qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx));
1402 [ - + ]: 1486 : if (!qpair_ctx) {
1403 : 0 : SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n");
1404 : 0 : return -ENOMEM;
1405 : : }
1406 [ # # # # ]: 1486 : qpair_ctx->qpair = qpair;
1407 [ # # # # ]: 1486 : spdk_thread_send_msg(group->thread, _nvmf_qpair_disconnect_msg, qpair_ctx);
1408 : 1486 : return 0;
1409 : : }
1410 : :
1411 : 2571 : SPDK_DTRACE_PROBE2_TICKS(nvmf_qpair_disconnect, qpair, spdk_thread_get_id(group->thread));
1412 [ + + # # ]: 10725 : assert(spdk_nvmf_qpair_is_active(qpair));
1413 : 10725 : nvmf_qpair_set_state(qpair, SPDK_NVMF_QPAIR_DEACTIVATING);
1414 : :
1415 : 10725 : qpair_ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_ctx));
1416 [ + + ]: 10725 : if (!qpair_ctx) {
1417 : 0 : SPDK_ERRLOG("Unable to allocate context for nvmf_qpair_disconnect\n");
1418 : 0 : return -ENOMEM;
1419 : : }
1420 : :
1421 [ + - + - ]: 10725 : qpair_ctx->qpair = qpair;
1422 : :
1423 : : /* Check for outstanding I/O */
1424 [ + + + - : 10725 : if (!TAILQ_EMPTY(&qpair->outstanding)) {
+ - + + ]
1425 : 829 : SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_drain_qpair, qpair, spdk_thread_get_id(group->thread));
1426 [ + - + - ]: 2645 : qpair->state_cb = _nvmf_qpair_destroy;
1427 [ + - + - ]: 2645 : qpair->state_cb_arg = qpair_ctx;
1428 : 2645 : nvmf_qpair_abort_pending_zcopy_reqs(qpair);
1429 : 2645 : nvmf_qpair_free_aer(qpair);
1430 : 2645 : return 0;
1431 : : }
1432 : :
1433 : 8080 : _nvmf_qpair_destroy(qpair_ctx, 0);
1434 : :
1435 : 8080 : return 0;
1436 : 1749 : }
1437 : :
1438 : : int
1439 : 298 : spdk_nvmf_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair,
1440 : : struct spdk_nvme_transport_id *trid)
1441 : : {
1442 [ - + ]: 298 : memset(trid, 0, sizeof(*trid));
1443 : 298 : return nvmf_transport_qpair_get_peer_trid(qpair, trid);
1444 : : }
1445 : :
1446 : : int
1447 : 0 : spdk_nvmf_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair,
1448 : : struct spdk_nvme_transport_id *trid)
1449 : : {
1450 [ # # ]: 0 : memset(trid, 0, sizeof(*trid));
1451 : 0 : return nvmf_transport_qpair_get_local_trid(qpair, trid);
1452 : : }
1453 : :
1454 : : int
1455 : 14093 : spdk_nvmf_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair,
1456 : : struct spdk_nvme_transport_id *trid)
1457 : : {
1458 [ + + ]: 14093 : memset(trid, 0, sizeof(*trid));
1459 : 14093 : return nvmf_transport_qpair_get_listen_trid(qpair, trid);
1460 : : }
1461 : :
1462 : : static int
1463 : 26303 : poll_group_update_subsystem(struct spdk_nvmf_poll_group *group,
1464 : : struct spdk_nvmf_subsystem *subsystem)
1465 : : {
1466 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1467 : : uint32_t i, j;
1468 : : struct spdk_nvmf_ns *ns;
1469 : : struct spdk_nvmf_registrant *reg, *tmp;
1470 : : struct spdk_io_channel *ch;
1471 : : struct spdk_nvmf_subsystem_pg_ns_info *ns_info;
1472 : : struct spdk_nvmf_ctrlr *ctrlr;
1473 : : bool ns_changed;
1474 : :
1475 : : /* Make sure our poll group has memory for this subsystem allocated */
1476 [ + + + - : 26303 : if (subsystem->id >= group->num_sgroups) {
+ - + - -
+ ]
1477 : 0 : return -ENOMEM;
1478 : : }
1479 : :
1480 [ + - + - : 26303 : sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1481 : :
1482 : : /* Make sure the array of namespace information is the correct size */
1483 [ + + + + : 26303 : if (sgroup->num_ns == 0 && subsystem->max_nsid > 0) {
+ + + - +
- + + ]
1484 : : /* First allocation */
1485 [ + - + - : 1239 : sgroup->ns_info = calloc(subsystem->max_nsid, sizeof(struct spdk_nvmf_subsystem_pg_ns_info));
+ - + - ]
1486 [ + + + - : 1239 : if (!sgroup->ns_info) {
+ - ]
1487 : 0 : return -ENOMEM;
1488 : : }
1489 [ + - + - : 1239 : sgroup->num_ns = subsystem->max_nsid;
+ - + - ]
1490 : 40 : }
1491 : :
1492 : 26303 : ns_changed = false;
1493 : :
1494 : : /* Detect bdevs that were added or removed */
1495 [ + + + - : 371321 : for (i = 0; i < sgroup->num_ns; i++) {
+ + ]
1496 [ + - + - : 345018 : ns = subsystem->ns[i];
+ - + - ]
1497 [ + - + - : 345018 : ns_info = &sgroup->ns_info[i];
+ - ]
1498 [ + - + - ]: 345018 : ch = ns_info->channel;
1499 : :
1500 [ + + + + ]: 345018 : if (ns == NULL && ch == NULL) {
1501 : : /* Both NULL. Leave empty */
1502 [ + + + - ]: 35237 : } else if (ns == NULL && ch != NULL) {
1503 : : /* There was a channel here, but the namespace is gone. */
1504 : 7686 : ns_changed = true;
1505 : 7686 : spdk_put_io_channel(ch);
1506 [ # # # # ]: 7686 : ns_info->channel = NULL;
1507 [ + - + + ]: 23860 : } else if (ns != NULL && ch == NULL) {
1508 : : /* A namespace appeared but there is no channel yet */
1509 : 8736 : ns_changed = true;
1510 [ + - + - ]: 8736 : ch = spdk_bdev_get_io_channel(ns->desc);
1511 [ - + ]: 8736 : if (ch == NULL) {
1512 : 0 : SPDK_ERRLOG("Could not allocate I/O channel.\n");
1513 : 0 : return -ENOMEM;
1514 : : }
1515 [ + - + - ]: 8736 : ns_info->channel = ch;
1516 [ + + + - : 15164 : } else if (spdk_uuid_compare(&ns_info->uuid, spdk_bdev_get_uuid(ns->bdev)) != 0) {
+ - - + ]
1517 : : /* A namespace was here before, but was replaced by a new one. */
1518 : 0 : ns_changed = true;
1519 [ # # # # ]: 0 : spdk_put_io_channel(ns_info->channel);
1520 [ # # ]: 0 : memset(ns_info, 0, sizeof(*ns_info));
1521 : :
1522 [ # # # # ]: 0 : ch = spdk_bdev_get_io_channel(ns->desc);
1523 [ # # ]: 0 : if (ch == NULL) {
1524 : 0 : SPDK_ERRLOG("Could not allocate I/O channel.\n");
1525 : 0 : return -ENOMEM;
1526 : : }
1527 [ # # # # ]: 0 : ns_info->channel = ch;
1528 [ + + + - : 15124 : } else if (ns_info->num_blocks != spdk_bdev_get_num_blocks(ns->bdev)) {
+ - + - -
+ ]
1529 : : /* Namespace is still there but size has changed */
1530 [ - + - + : 465 : SPDK_DEBUGLOG(nvmf, "Namespace resized: subsystem_id %u,"
# # # # #
# # # # #
# # # # #
# # # ]
1531 : : " nsid %u, pg %p, old %" PRIu64 ", new %" PRIu64 "\n",
1532 : : subsystem->id,
1533 : : ns->nsid,
1534 : : group,
1535 : : ns_info->num_blocks,
1536 : : spdk_bdev_get_num_blocks(ns->bdev));
1537 : 465 : ns_changed = true;
1538 [ + + + - : 14659 : } else if (ns_info->anagrpid != ns->anagrpid) {
+ - + - +
- ]
1539 : : /* Namespace is still there but ANA group ID has changed */
1540 [ # # # # : 0 : SPDK_DEBUGLOG(nvmf, "ANA group ID changed: subsystem_id %u,"
# # # # #
# # # # #
# # # # #
# # # ]
1541 : : "nsid %u, pg %p, old %u, new %u\n",
1542 : : subsystem->id,
1543 : : ns->nsid,
1544 : : group,
1545 : : ns_info->anagrpid,
1546 : : ns->anagrpid);
1547 : 0 : ns_changed = true;
1548 : 0 : }
1549 : :
1550 [ + + ]: 345018 : if (ns == NULL) {
1551 [ + + ]: 321158 : memset(ns_info, 0, sizeof(*ns_info));
1552 : 3691 : } else {
1553 [ + - + - : 23860 : ns_info->uuid = *spdk_bdev_get_uuid(ns->bdev);
+ - ]
1554 [ + - + - : 23860 : ns_info->num_blocks = spdk_bdev_get_num_blocks(ns->bdev);
+ - + - ]
1555 [ + - + - : 23860 : ns_info->anagrpid = ns->anagrpid;
+ - + - ]
1556 [ + - + - : 23860 : ns_info->crkey = ns->crkey;
+ - + - ]
1557 [ + - + - : 23860 : ns_info->rtype = ns->rtype;
+ - + - ]
1558 [ + + + - : 23860 : if (ns->holder) {
- + ]
1559 [ # # # # : 0 : ns_info->holder_id = ns->holder->hostid;
# # # # ]
1560 : 0 : }
1561 : :
1562 [ + + + - ]: 23860 : memset(&ns_info->reg_hostid, 0, SPDK_NVMF_MAX_NUM_REGISTRANTS * sizeof(struct spdk_uuid));
1563 : 23860 : j = 0;
1564 [ + + + + : 23860 : TAILQ_FOREACH_SAFE(reg, &ns->registrants, link, tmp) {
+ - + - #
# # # # #
- + ]
1565 [ # # ]: 0 : if (j >= SPDK_NVMF_MAX_NUM_REGISTRANTS) {
1566 : 0 : SPDK_ERRLOG("Maximum %u registrants can support.\n", SPDK_NVMF_MAX_NUM_REGISTRANTS);
1567 : 0 : return -EINVAL;
1568 : : }
1569 [ # # # # : 0 : ns_info->reg_hostid[j++] = reg->hostid;
# # # # ]
1570 : 0 : }
1571 : : }
1572 : 3745 : }
1573 : :
1574 [ + + + + ]: 26303 : if (ns_changed) {
1575 [ + + - + : 28367 : TAILQ_FOREACH(ctrlr, &subsystem->ctrlrs, link) {
- + - + #
# # # #
# ]
1576 [ + + # # : 11483 : if (ctrlr->thread != spdk_get_thread()) {
# # ]
1577 : 7638 : continue;
1578 : : }
1579 : : /* It is possible that a ctrlr was added but the admin_qpair hasn't been
1580 : : * assigned yet.
1581 : : */
1582 [ + + # # : 3845 : if (!ctrlr->admin_qpair) {
# # ]
1583 : 8 : continue;
1584 : : }
1585 [ + - # # : 3837 : if (ctrlr->admin_qpair->group == group) {
# # # # #
# ]
1586 : 3837 : nvmf_ctrlr_async_event_ns_notice(ctrlr);
1587 : 3837 : nvmf_ctrlr_async_event_ana_change_notice(ctrlr);
1588 : 0 : }
1589 : 0 : }
1590 : 40 : }
1591 : :
1592 : 26303 : return 0;
1593 : 282 : }
1594 : :
1595 : : int
1596 : 0 : nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group,
1597 : : struct spdk_nvmf_subsystem *subsystem)
1598 : : {
1599 : 0 : return poll_group_update_subsystem(group, subsystem);
1600 : : }
1601 : :
1602 : : int
1603 : 4225 : nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group,
1604 : : struct spdk_nvmf_subsystem *subsystem,
1605 : : spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg)
1606 : : {
1607 : 4225 : int rc = 0;
1608 [ + - + - : 4225 : struct spdk_nvmf_subsystem_poll_group *sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1609 : : struct spdk_nvmf_request *req, *tmp;
1610 : : uint32_t i;
1611 : :
1612 [ + + + - : 4225 : if (!TAILQ_EMPTY(&sgroup->queued)) {
+ - - + ]
1613 : 0 : SPDK_ERRLOG("sgroup->queued not empty when adding subsystem\n");
1614 [ # # # # : 0 : TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) {
# # # # #
# # # # #
# # ]
1615 [ # # # # : 0 : TAILQ_REMOVE(&sgroup->queued, req, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
1616 [ # # ]: 0 : if (nvmf_transport_req_free(req)) {
1617 : 0 : SPDK_ERRLOG("Transport request free error!\n");
1618 : 0 : }
1619 : 0 : }
1620 : 0 : }
1621 : :
1622 : 4225 : rc = poll_group_update_subsystem(group, subsystem);
1623 [ + + ]: 4225 : if (rc) {
1624 : 0 : nvmf_poll_group_remove_subsystem(group, subsystem, NULL, NULL);
1625 : 0 : goto fini;
1626 : : }
1627 : :
1628 [ + - + - ]: 4225 : sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
1629 : :
1630 [ + + + - : 40585 : for (i = 0; i < sgroup->num_ns; i++) {
+ + ]
1631 [ + - + - : 36360 : sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
+ - + - +
- ]
1632 : 1453 : }
1633 : :
1634 : 4021 : fini:
1635 [ + + ]: 4225 : if (cb_fn) {
1636 [ - + + - ]: 2728 : cb_fn(cb_arg, rc);
1637 : 121 : }
1638 : :
1639 : 1019 : SPDK_DTRACE_PROBE2_TICKS(nvmf_poll_group_add_subsystem, spdk_thread_get_id(group->thread),
1640 : : subsystem->subnqn);
1641 : :
1642 : 4225 : return rc;
1643 : : }
1644 : :
1645 : : static void
1646 : 2728 : _nvmf_poll_group_remove_subsystem_cb(void *ctx, int status)
1647 : : {
1648 : 2728 : struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx;
1649 : : struct spdk_nvmf_subsystem *subsystem;
1650 : : struct spdk_nvmf_poll_group *group;
1651 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1652 : 2728 : spdk_nvmf_poll_group_mod_done cpl_fn = NULL;
1653 : 2728 : void *cpl_ctx = NULL;
1654 : : uint32_t nsid;
1655 : :
1656 [ + - + - ]: 2728 : group = qpair_ctx->group;
1657 [ + - + - ]: 2728 : subsystem = qpair_ctx->subsystem;
1658 [ + - + - ]: 2728 : cpl_fn = qpair_ctx->cpl_fn;
1659 [ + - + - ]: 2728 : cpl_ctx = qpair_ctx->cpl_ctx;
1660 [ + - + - : 2728 : sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1661 : :
1662 [ + + ]: 2728 : if (status) {
1663 : 0 : goto fini;
1664 : : }
1665 : :
1666 [ + + + - : 39084 : for (nsid = 0; nsid < sgroup->num_ns; nsid++) {
+ + ]
1667 [ + + + - : 36356 : if (sgroup->ns_info[nsid].channel) {
+ - + - +
- + + ]
1668 [ + - + - : 1046 : spdk_put_io_channel(sgroup->ns_info[nsid].channel);
+ - + - +
- ]
1669 [ + - + - : 1046 : sgroup->ns_info[nsid].channel = NULL;
+ - + - +
- ]
1670 : 39 : }
1671 : 1248 : }
1672 : :
1673 [ + - + - ]: 2728 : sgroup->num_ns = 0;
1674 [ + - + - ]: 2728 : free(sgroup->ns_info);
1675 [ + - + - ]: 2728 : sgroup->ns_info = NULL;
1676 : 2607 : fini:
1677 : 2728 : free(qpair_ctx);
1678 [ + + ]: 2728 : if (cpl_fn) {
1679 [ - + + - ]: 2728 : cpl_fn(cpl_ctx, status);
1680 : 121 : }
1681 : 2728 : }
1682 : :
1683 : : static void nvmf_poll_group_remove_subsystem_msg(void *ctx);
1684 : :
1685 : : static void
1686 : 447613 : nvmf_poll_group_remove_subsystem_msg(void *ctx)
1687 : : {
1688 : : struct spdk_nvmf_qpair *qpair, *qpair_tmp;
1689 : : struct spdk_nvmf_subsystem *subsystem;
1690 : : struct spdk_nvmf_poll_group *group;
1691 : 447613 : struct nvmf_qpair_disconnect_many_ctx *qpair_ctx = ctx;
1692 : 447613 : bool qpairs_found = false;
1693 : 447613 : int rc = 0;
1694 : :
1695 [ + - + - ]: 447613 : group = qpair_ctx->group;
1696 [ + - + - ]: 447613 : subsystem = qpair_ctx->subsystem;
1697 : :
1698 [ + + + - : 2226746 : TAILQ_FOREACH_SAFE(qpair, &group->qpairs, link, qpair_tmp) {
+ - + + +
- + - + -
+ + ]
1699 [ + - + + : 1779133 : if ((qpair->ctrlr != NULL) && (qpair->ctrlr->subsys == subsystem)) {
+ - + - +
- + - + -
+ - ]
1700 : 1777572 : qpairs_found = true;
1701 : 1777572 : rc = spdk_nvmf_qpair_disconnect(qpair);
1702 [ + + - + ]: 1777572 : if (rc && rc != -EINPROGRESS) {
1703 : 0 : break;
1704 : : }
1705 : 0 : }
1706 : 5 : }
1707 : :
1708 [ + + - + ]: 447613 : if (!qpairs_found) {
1709 : 2728 : _nvmf_poll_group_remove_subsystem_cb(ctx, 0);
1710 : 2728 : return;
1711 : : }
1712 : :
1713 : : /* Some qpairs are in process of being disconnected. Send a message and try to remove them again */
1714 : 444885 : spdk_thread_send_msg(spdk_get_thread(), nvmf_poll_group_remove_subsystem_msg, ctx);
1715 : 121 : }
1716 : :
1717 : : void
1718 : 2728 : nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group,
1719 : : struct spdk_nvmf_subsystem *subsystem,
1720 : : spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg)
1721 : : {
1722 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1723 : : struct nvmf_qpair_disconnect_many_ctx *ctx;
1724 : : uint32_t i;
1725 : :
1726 : 687 : SPDK_DTRACE_PROBE3_TICKS(nvmf_poll_group_remove_subsystem, group, spdk_thread_get_id(group->thread),
1727 : : subsystem->subnqn);
1728 : :
1729 : 2728 : ctx = calloc(1, sizeof(struct nvmf_qpair_disconnect_many_ctx));
1730 [ + + ]: 2728 : if (!ctx) {
1731 : 0 : SPDK_ERRLOG("Unable to allocate memory for context to remove poll subsystem\n");
1732 [ # # ]: 0 : if (cb_fn) {
1733 [ # # # # ]: 0 : cb_fn(cb_arg, -1);
1734 : 0 : }
1735 : 0 : return;
1736 : : }
1737 : :
1738 [ + - + - ]: 2728 : ctx->group = group;
1739 [ + - + - ]: 2728 : ctx->subsystem = subsystem;
1740 [ + - + - ]: 2728 : ctx->cpl_fn = cb_fn;
1741 [ + - + - ]: 2728 : ctx->cpl_ctx = cb_arg;
1742 : :
1743 [ + - + - : 2728 : sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1744 [ + - + - ]: 2728 : sgroup->state = SPDK_NVMF_SUBSYSTEM_INACTIVE;
1745 : :
1746 [ + + + - : 39084 : for (i = 0; i < sgroup->num_ns; i++) {
+ + ]
1747 [ + - + - : 36356 : sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_INACTIVE;
+ - + - +
- ]
1748 : 1248 : }
1749 : :
1750 : 2728 : nvmf_poll_group_remove_subsystem_msg(ctx);
1751 : 121 : }
1752 : :
1753 : : void
1754 : 22078 : nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group,
1755 : : struct spdk_nvmf_subsystem *subsystem,
1756 : : uint32_t nsid,
1757 : : spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg)
1758 : : {
1759 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1760 : 22078 : struct spdk_nvmf_subsystem_pg_ns_info *ns_info = NULL;
1761 : 22078 : int rc = 0;
1762 : : uint32_t i;
1763 : :
1764 [ + + + - : 22078 : if (subsystem->id >= group->num_sgroups) {
+ - + - -
+ ]
1765 : 0 : rc = -1;
1766 : 0 : goto fini;
1767 : : }
1768 : :
1769 [ + - + - : 22078 : sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1770 [ + + + - : 22078 : if (sgroup->state == SPDK_NVMF_SUBSYSTEM_PAUSED) {
- + ]
1771 : 0 : goto fini;
1772 : : }
1773 [ + - + - ]: 22078 : sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSING;
1774 : :
1775 [ + + ]: 22078 : if (nsid == SPDK_NVME_GLOBAL_NS_TAG) {
1776 [ # # # # : 0 : for (i = 0; i < sgroup->num_ns; i++) {
# # ]
1777 [ # # # # : 0 : ns_info = &sgroup->ns_info[i];
# # ]
1778 [ # # # # ]: 0 : ns_info->state = SPDK_NVMF_SUBSYSTEM_PAUSING;
1779 : 0 : }
1780 : 0 : } else {
1781 : : /* NOTE: This implicitly also checks for 0, since 0 - 1 wraps around to UINT32_MAX. */
1782 [ + + + - : 22078 : if (nsid - 1 < sgroup->num_ns) {
+ + ]
1783 [ + - + - : 11021 : ns_info = &sgroup->ns_info[nsid - 1];
+ - ]
1784 [ + - + - ]: 11021 : ns_info->state = SPDK_NVMF_SUBSYSTEM_PAUSING;
1785 : 39 : }
1786 : : }
1787 : :
1788 [ + + + - : 22078 : if (sgroup->mgmt_io_outstanding > 0) {
- + ]
1789 [ - + # # : 2 : assert(sgroup->cb_fn == NULL);
# # # # ]
1790 [ # # # # ]: 2 : sgroup->cb_fn = cb_fn;
1791 [ - + # # : 2 : assert(sgroup->cb_arg == NULL);
# # # # ]
1792 [ # # # # ]: 2 : sgroup->cb_arg = cb_arg;
1793 : 2 : return;
1794 : : }
1795 : :
1796 [ + + ]: 22076 : if (nsid == SPDK_NVME_GLOBAL_NS_TAG) {
1797 [ # # # # : 0 : for (i = 0; i < sgroup->num_ns; i++) {
# # ]
1798 [ # # # # : 0 : ns_info = &sgroup->ns_info[i];
# # ]
1799 : :
1800 [ # # # # : 0 : if (ns_info->io_outstanding > 0) {
# # ]
1801 [ # # # # : 0 : assert(sgroup->cb_fn == NULL);
# # # # ]
1802 [ # # # # ]: 0 : sgroup->cb_fn = cb_fn;
1803 [ # # # # : 0 : assert(sgroup->cb_arg == NULL);
# # # # ]
1804 [ # # # # ]: 0 : sgroup->cb_arg = cb_arg;
1805 : 0 : return;
1806 : : }
1807 : 0 : }
1808 : 0 : } else {
1809 [ + + + + : 22076 : if (ns_info != NULL && ns_info->io_outstanding > 0) {
+ - + - ]
1810 [ - + # # : 1727 : assert(sgroup->cb_fn == NULL);
# # # # ]
1811 [ # # # # ]: 1727 : sgroup->cb_fn = cb_fn;
1812 [ - + # # : 1727 : assert(sgroup->cb_arg == NULL);
# # # # ]
1813 [ # # # # ]: 1727 : sgroup->cb_arg = cb_arg;
1814 : 1727 : return;
1815 : : }
1816 : : }
1817 : :
1818 [ + + + - : 20349 : assert(sgroup->mgmt_io_outstanding == 0);
+ - # # ]
1819 [ + - + - ]: 20349 : sgroup->state = SPDK_NVMF_SUBSYSTEM_PAUSED;
1820 : 20271 : fini:
1821 [ + - ]: 20349 : if (cb_fn) {
1822 [ - + + - ]: 20349 : cb_fn(cb_arg, rc);
1823 : 78 : }
1824 : 78 : }
1825 : :
1826 : : void
1827 : 22078 : nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group,
1828 : : struct spdk_nvmf_subsystem *subsystem,
1829 : : spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg)
1830 : : {
1831 : : struct spdk_nvmf_request *req, *tmp;
1832 : : struct spdk_nvmf_subsystem_poll_group *sgroup;
1833 : 22078 : int rc = 0;
1834 : : uint32_t i;
1835 : :
1836 [ + + + - : 22078 : if (subsystem->id >= group->num_sgroups) {
+ - + - -
+ ]
1837 : 0 : rc = -1;
1838 : 0 : goto fini;
1839 : : }
1840 : :
1841 [ + - + - : 22078 : sgroup = &group->sgroups[subsystem->id];
+ - + - +
- ]
1842 : :
1843 [ + + + - : 22078 : if (sgroup->state == SPDK_NVMF_SUBSYSTEM_ACTIVE) {
- + ]
1844 : 0 : goto fini;
1845 : : }
1846 : :
1847 : 22078 : rc = poll_group_update_subsystem(group, subsystem);
1848 [ + + ]: 22078 : if (rc) {
1849 : 0 : goto fini;
1850 : : }
1851 : :
1852 [ + + + - : 330736 : for (i = 0; i < sgroup->num_ns; i++) {
+ + ]
1853 [ + - + - : 308658 : sgroup->ns_info[i].state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
+ - + - +
- ]
1854 : 2496 : }
1855 : :
1856 [ + - + - ]: 22078 : sgroup->state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
1857 : :
1858 : : /* Release all queued requests */
1859 [ + + + - : 204409 : TAILQ_FOREACH_SAFE(req, &sgroup->queued, link, tmp) {
+ - + - #
# # # # #
- + ]
1860 [ + + # # : 182331 : TAILQ_REMOVE(&sgroup->queued, req, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
1861 [ + + ]: 182331 : if (spdk_nvmf_request_using_zcopy(req)) {
1862 : 174628 : spdk_nvmf_request_zcopy_start(req);
1863 : 0 : } else {
1864 : 7703 : spdk_nvmf_request_exec(req);
1865 : : }
1866 : :
1867 : 78 : }
1868 : 22000 : fini:
1869 [ + + ]: 22078 : if (cb_fn) {
1870 [ - + + - ]: 22078 : cb_fn(cb_arg, rc);
1871 : 78 : }
1872 : 22078 : }
1873 : :
1874 : :
1875 : : struct spdk_nvmf_poll_group *
1876 : 10725 : spdk_nvmf_get_optimal_poll_group(struct spdk_nvmf_qpair *qpair)
1877 : : {
1878 : : struct spdk_nvmf_transport_poll_group *tgroup;
1879 : :
1880 [ + - + - ]: 10725 : tgroup = nvmf_transport_get_optimal_poll_group(qpair->transport, qpair);
1881 : :
1882 [ + + ]: 10725 : if (tgroup == NULL) {
1883 : 0 : return NULL;
1884 : : }
1885 : :
1886 [ + - + - ]: 10725 : return tgroup->group;
1887 : 1749 : }
1888 : :
1889 : : void
1890 : 44 : spdk_nvmf_poll_group_dump_stat(struct spdk_nvmf_poll_group *group, struct spdk_json_write_ctx *w)
1891 : : {
1892 : : struct spdk_nvmf_transport_poll_group *tgroup;
1893 : :
1894 : 44 : spdk_json_write_object_begin(w);
1895 : :
1896 : 44 : spdk_json_write_named_string(w, "name", spdk_thread_get_name(spdk_get_thread()));
1897 [ # # # # : 44 : spdk_json_write_named_uint32(w, "admin_qpairs", group->stat.admin_qpairs);
# # ]
1898 [ # # # # : 44 : spdk_json_write_named_uint32(w, "io_qpairs", group->stat.io_qpairs);
# # ]
1899 [ # # # # : 44 : spdk_json_write_named_uint32(w, "current_admin_qpairs", group->stat.current_admin_qpairs);
# # ]
1900 [ # # # # : 44 : spdk_json_write_named_uint32(w, "current_io_qpairs", group->stat.current_io_qpairs);
# # ]
1901 [ # # # # : 44 : spdk_json_write_named_uint64(w, "pending_bdev_io", group->stat.pending_bdev_io);
# # ]
1902 [ # # # # : 44 : spdk_json_write_named_uint64(w, "completed_nvme_io", group->stat.completed_nvme_io);
# # ]
1903 : :
1904 : 44 : spdk_json_write_named_array_begin(w, "transports");
1905 : :
1906 [ + + # # : 76 : TAILQ_FOREACH(tgroup, &group->tgroups, link) {
# # # # #
# # # #
# ]
1907 : 32 : spdk_json_write_object_begin(w);
1908 : : /*
1909 : : * The trtype field intentionally contains a transport name as this is more informative.
1910 : : * The field has not been renamed for backward compatibility.
1911 : : */
1912 [ # # # # ]: 32 : spdk_json_write_named_string(w, "trtype", spdk_nvmf_get_transport_name(tgroup->transport));
1913 : :
1914 [ + + # # : 32 : if (tgroup->transport->ops->poll_group_dump_stat) {
# # # # #
# # # #
# ]
1915 [ # # # # : 8 : tgroup->transport->ops->poll_group_dump_stat(tgroup, w);
# # # # #
# # # # #
# # ]
1916 : 0 : }
1917 : :
1918 : 32 : spdk_json_write_object_end(w);
1919 : 0 : }
1920 : :
1921 : 44 : spdk_json_write_array_end(w);
1922 : 44 : spdk_json_write_object_end(w);
1923 : 44 : }
|