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