Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : /*
8 : : * NVMe over Fabrics discovery service
9 : : */
10 : :
11 : : #include "spdk/stdinc.h"
12 : :
13 : : #include "nvmf_internal.h"
14 : : #include "transport.h"
15 : :
16 : : #include "spdk/string.h"
17 : : #include "spdk/trace.h"
18 : : #include "spdk/nvmf_spec.h"
19 : : #include "spdk_internal/assert.h"
20 : :
21 : : #include "spdk/log.h"
22 : :
23 : : void
24 : 1961 : nvmf_update_discovery_log(struct spdk_nvmf_tgt *tgt, const char *hostnqn)
25 : : {
26 : : struct spdk_nvmf_subsystem *discovery_subsystem;
27 : : struct spdk_nvmf_ctrlr *ctrlr;
28 : :
29 : 1961 : tgt->discovery_genctr++;
30 : 1961 : discovery_subsystem = spdk_nvmf_tgt_find_subsystem(tgt, SPDK_NVMF_DISCOVERY_NQN);
31 : :
32 [ + + ]: 1961 : if (discovery_subsystem) {
33 : : /** There is a change in discovery log for hosts with given hostnqn */
34 [ + + ]: 1703 : TAILQ_FOREACH(ctrlr, &discovery_subsystem->ctrlrs, link) {
35 [ - + - - : 14 : if (hostnqn == NULL || strcmp(hostnqn, ctrlr->hostnqn) == 0) {
- - - - ]
36 : 14 : spdk_thread_send_msg(ctrlr->thread, nvmf_ctrlr_async_event_discovery_log_change_notice, ctrlr);
37 : : }
38 : : }
39 : : }
40 : 1961 : }
41 : :
42 : : static bool
43 : 480 : nvmf_discovery_compare_trtype(const struct spdk_nvme_transport_id *trid1,
44 : : const struct spdk_nvme_transport_id *trid2)
45 : : {
46 [ - + ]: 480 : if (trid1->trtype == SPDK_NVME_TRANSPORT_CUSTOM) {
47 [ # # # # ]: 0 : return strcasecmp(trid1->trstring, trid2->trstring) == 0;
48 : : } else {
49 : 480 : return trid1->trtype == trid2->trtype;
50 : : }
51 : : }
52 : :
53 : : static bool
54 : 618 : nvmf_discovery_compare_tr_addr(const struct spdk_nvme_transport_id *trid1,
55 : : const struct spdk_nvme_transport_id *trid2)
56 : : {
57 [ + - + + : 618 : return trid1->adrfam == trid2->adrfam && strcasecmp(trid1->traddr, trid2->traddr) == 0;
- + + + ]
58 : : }
59 : :
60 : : static bool
61 : 200 : nvmf_discovery_compare_tr_svcid(const struct spdk_nvme_transport_id *trid1,
62 : : const struct spdk_nvme_transport_id *trid2)
63 : : {
64 [ - + - + ]: 200 : return strcasecmp(trid1->trsvcid, trid2->trsvcid) == 0;
65 : : }
66 : :
67 : : static bool
68 : 1544 : nvmf_discovery_compare_trid(uint32_t filter,
69 : : const struct spdk_nvme_transport_id *trid1,
70 : : const struct spdk_nvme_transport_id *trid2)
71 : : {
72 [ + + ]: 1544 : if ((filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_TYPE) != 0 &&
73 [ + + ]: 480 : !nvmf_discovery_compare_trtype(trid1, trid2)) {
74 [ - + - + ]: 240 : SPDK_DEBUGLOG(nvmf, "transport type mismatch between %d (%s) and %d (%s)\n",
75 : : trid1->trtype, trid1->trstring, trid2->trtype, trid2->trstring);
76 : 240 : return false;
77 : : }
78 : :
79 [ + + ]: 1304 : if ((filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_ADDRESS) != 0 &&
80 [ + + ]: 618 : !nvmf_discovery_compare_tr_addr(trid1, trid2)) {
81 [ - + - + ]: 304 : SPDK_DEBUGLOG(nvmf, "transport addr mismatch between %s and %s\n",
82 : : trid1->traddr, trid2->traddr);
83 : 304 : return false;
84 : : }
85 : :
86 [ + + ]: 1000 : if ((filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_SVCID) != 0 &&
87 [ + + ]: 200 : !nvmf_discovery_compare_tr_svcid(trid1, trid2)) {
88 [ - + - + ]: 110 : SPDK_DEBUGLOG(nvmf, "transport svcid mismatch between %s and %s\n",
89 : : trid1->trsvcid, trid2->trsvcid);
90 : 110 : return false;
91 : : }
92 : :
93 : 890 : return true;
94 : : }
95 : :
96 : : static struct spdk_nvmf_discovery_log_page *
97 : 482 : nvmf_generate_discovery_log(struct spdk_nvmf_tgt *tgt, const char *hostnqn, size_t *log_page_size,
98 : : struct spdk_nvme_transport_id *cmd_source_trid)
99 : : {
100 : 482 : uint64_t numrec = 0;
101 : : struct spdk_nvmf_subsystem *subsystem;
102 : : struct spdk_nvmf_subsystem_listener *listener;
103 : : struct spdk_nvmf_discovery_log_page_entry *entry;
104 : : struct spdk_nvmf_discovery_log_page *disc_log;
105 : : size_t cur_size;
106 : : struct spdk_nvmf_referral *referral;
107 : :
108 [ - + - + ]: 482 : SPDK_DEBUGLOG(nvmf, "Generating log page for genctr %" PRIu64 "\n",
109 : : tgt->discovery_genctr);
110 : :
111 : 482 : cur_size = sizeof(struct spdk_nvmf_discovery_log_page);
112 : 482 : disc_log = calloc(1, cur_size);
113 [ - + ]: 482 : if (disc_log == NULL) {
114 : 0 : SPDK_ERRLOG("Discovery log page memory allocation error\n");
115 : 0 : return NULL;
116 : : }
117 : :
118 [ + + ]: 514 : for (subsystem = spdk_nvmf_subsystem_get_first(tgt);
119 [ + + ]: 1229 : subsystem != NULL;
120 : 812 : subsystem = spdk_nvmf_subsystem_get_next(subsystem)) {
121 [ + + ]: 812 : if ((subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE) ||
122 [ - + ]: 807 : (subsystem->state == SPDK_NVMF_SUBSYSTEM_DEACTIVATING)) {
123 : 5 : continue;
124 : : }
125 : :
126 [ + + ]: 807 : if (!spdk_nvmf_subsystem_host_allowed(subsystem, hostnqn)) {
127 : 8 : continue;
128 : : }
129 : :
130 [ + + ]: 2343 : for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL;
131 : 1544 : listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) {
132 : :
133 [ + + ]: 1544 : if (!nvmf_discovery_compare_trid(tgt->discovery_filter, listener->trid, cmd_source_trid)) {
134 : 654 : continue;
135 : : }
136 : :
137 [ - + - + ]: 890 : SPDK_DEBUGLOG(nvmf, "listener %s:%s trtype %s\n", listener->trid->traddr, listener->trid->trsvcid,
138 : : listener->trid->trstring);
139 : :
140 : 890 : size_t new_size = cur_size + sizeof(*entry);
141 : 890 : void *new_log_page = realloc(disc_log, new_size);
142 : :
143 [ - + ]: 890 : if (new_log_page == NULL) {
144 : 0 : SPDK_ERRLOG("Discovery log page memory allocation error\n");
145 : 0 : break;
146 : : }
147 : :
148 : 890 : disc_log = new_log_page;
149 : 890 : cur_size = new_size;
150 : :
151 : 890 : entry = &disc_log->entries[numrec];
152 [ - + ]: 890 : memset(entry, 0, sizeof(*entry));
153 : 890 : entry->portid = listener->id;
154 : 890 : entry->cntlid = 0xffff;
155 : 890 : entry->asqsz = listener->transport->opts.max_aq_depth;
156 : 890 : entry->subtype = subsystem->subtype;
157 [ - + ]: 890 : snprintf(entry->subnqn, sizeof(entry->subnqn), "%s", subsystem->subnqn);
158 : :
159 [ + + ]: 890 : if (subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT) {
160 : : /* Each listener in the Current Discovery Subsystem provides access
161 : : * to the same Discovery Log Pages, so set the Duplicate Returned
162 : : * Information flag. */
163 : 344 : entry->eflags |= SPDK_NVMF_DISCOVERY_LOG_EFLAGS_DUPRETINFO;
164 : : /* Since the SPDK NVMeoF target supports Asynchronous Event Request
165 : : * and Keep Alive commands, set the Explicit Persistent Connection
166 : : * Support for Discovery flag. */
167 : 344 : entry->eflags |= SPDK_NVMF_DISCOVERY_LOG_EFLAGS_EPCSD;
168 : : }
169 : :
170 : 890 : nvmf_transport_listener_discover(listener->transport, listener->trid, entry);
171 : :
172 : 890 : numrec++;
173 : : }
174 : : }
175 : :
176 [ + + ]: 822 : TAILQ_FOREACH(referral, &tgt->referrals, link) {
177 [ - + - + ]: 340 : SPDK_DEBUGLOG(nvmf, "referral %s:%s trtype %s\n", referral->trid.traddr, referral->trid.trsvcid,
178 : : referral->trid.trstring);
179 : :
180 : 340 : size_t new_size = cur_size + sizeof(*entry);
181 : 340 : void *new_log_page = realloc(disc_log, new_size);
182 : :
183 [ - + ]: 340 : if (new_log_page == NULL) {
184 : 0 : SPDK_ERRLOG("Discovery log page memory allocation error\n");
185 : 0 : break;
186 : : }
187 : :
188 : 340 : disc_log = new_log_page;
189 : 340 : cur_size = new_size;
190 : :
191 : 340 : entry = &disc_log->entries[numrec];
192 [ - + - + ]: 340 : memcpy(entry, &referral->entry, sizeof(*entry));
193 : :
194 : 340 : numrec++;
195 : : }
196 : :
197 : :
198 : 482 : disc_log->numrec = numrec;
199 : 482 : disc_log->genctr = tgt->discovery_genctr;
200 : 482 : *log_page_size = cur_size;
201 : :
202 : 482 : return disc_log;
203 : : }
204 : :
205 : : void
206 : 482 : nvmf_get_discovery_log_page(struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov,
207 : : uint32_t iovcnt, uint64_t offset, uint32_t length,
208 : : struct spdk_nvme_transport_id *cmd_source_trid)
209 : : {
210 : 482 : size_t copy_len = 0;
211 : 482 : size_t zero_len = 0;
212 : : struct iovec *tmp;
213 : 482 : size_t log_page_size = 0;
214 : : struct spdk_nvmf_discovery_log_page *discovery_log_page;
215 : :
216 : 482 : discovery_log_page = nvmf_generate_discovery_log(tgt, hostnqn, &log_page_size, cmd_source_trid);
217 : :
218 : : /* Copy the valid part of the discovery log page, if any */
219 [ + - ]: 482 : if (discovery_log_page) {
220 [ + - ]: 482 : for (tmp = iov; tmp < iov + iovcnt; tmp++) {
221 : 482 : copy_len = spdk_min(tmp->iov_len, length);
222 : 482 : copy_len = spdk_min(log_page_size - offset, copy_len);
223 : :
224 [ - + - + ]: 482 : memcpy(tmp->iov_base, (char *)discovery_log_page + offset, copy_len);
225 : :
226 : 482 : offset += copy_len;
227 : 482 : length -= copy_len;
228 : 482 : zero_len = tmp->iov_len - copy_len;
229 [ + + - + ]: 482 : if (log_page_size <= offset || length == 0) {
230 : : break;
231 : : }
232 : : }
233 : : /* Zero out the rest of the payload */
234 [ + + ]: 482 : if (zero_len) {
235 [ - + ]: 243 : memset((char *)tmp->iov_base + copy_len, 0, zero_len);
236 : : }
237 : :
238 [ - + ]: 482 : for (++tmp; tmp < iov + iovcnt; tmp++) {
239 [ # # ]: 0 : memset((char *)tmp->iov_base, 0, tmp->iov_len);
240 : : }
241 : :
242 : 482 : free(discovery_log_page);
243 : : }
244 : 482 : }
|