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