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 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 tgt->discovery_genctr++; 30 discovery_subsystem = spdk_nvmf_tgt_find_subsystem(tgt, SPDK_NVMF_DISCOVERY_NQN); 31 32 if (discovery_subsystem) { 33 /** There is a change in discovery log for hosts with given hostnqn */ 34 TAILQ_FOREACH(ctrlr, &discovery_subsystem->ctrlrs, link) { 35 if (hostnqn == NULL || strcmp(hostnqn, ctrlr->hostnqn) == 0) { 36 spdk_thread_send_msg(ctrlr->thread, nvmf_ctrlr_async_event_discovery_log_change_notice, ctrlr); 37 } 38 } 39 } 40 } 41 42 static bool 43 nvmf_discovery_compare_trtype(const struct spdk_nvme_transport_id *trid1, 44 const struct spdk_nvme_transport_id *trid2) 45 { 46 if (trid1->trtype == SPDK_NVME_TRANSPORT_CUSTOM) { 47 return strcasecmp(trid1->trstring, trid2->trstring) == 0; 48 } else { 49 return trid1->trtype == trid2->trtype; 50 } 51 } 52 53 static bool 54 nvmf_discovery_compare_tr_addr(const struct spdk_nvme_transport_id *trid1, 55 const struct spdk_nvme_transport_id *trid2) 56 { 57 return trid1->adrfam == trid2->adrfam && strcasecmp(trid1->traddr, trid2->traddr) == 0; 58 } 59 60 static bool 61 nvmf_discovery_compare_tr_svcid(const struct spdk_nvme_transport_id *trid1, 62 const struct spdk_nvme_transport_id *trid2) 63 { 64 return strcasecmp(trid1->trsvcid, trid2->trsvcid) == 0; 65 } 66 67 static struct spdk_nvmf_discovery_log_page * 68 nvmf_generate_discovery_log(struct spdk_nvmf_tgt *tgt, const char *hostnqn, size_t *log_page_size, 69 struct spdk_nvme_transport_id *cmd_source_trid) 70 { 71 uint64_t numrec = 0; 72 struct spdk_nvmf_subsystem *subsystem; 73 struct spdk_nvmf_subsystem_listener *listener; 74 struct spdk_nvmf_discovery_log_page_entry *entry; 75 struct spdk_nvmf_discovery_log_page *disc_log; 76 size_t cur_size; 77 uint32_t sid; 78 79 SPDK_DEBUGLOG(nvmf, "Generating log page for genctr %" PRIu64 "\n", 80 tgt->discovery_genctr); 81 82 cur_size = sizeof(struct spdk_nvmf_discovery_log_page); 83 disc_log = calloc(1, cur_size); 84 if (disc_log == NULL) { 85 SPDK_ERRLOG("Discovery log page memory allocation error\n"); 86 return NULL; 87 } 88 89 for (sid = 0; sid < tgt->max_subsystems; sid++) { 90 subsystem = tgt->subsystems[sid]; 91 if ((subsystem == NULL) || 92 (subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE) || 93 (subsystem->state == SPDK_NVMF_SUBSYSTEM_DEACTIVATING)) { 94 continue; 95 } 96 97 if (!spdk_nvmf_subsystem_host_allowed(subsystem, hostnqn)) { 98 continue; 99 } 100 101 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 102 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 103 if (subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY) { 104 struct spdk_nvme_transport_id source_trid = *cmd_source_trid; 105 struct spdk_nvme_transport_id listener_trid = *listener->trid; 106 107 /* Do not generate an entry for the transport ID for the listener 108 * entry associated with the discovery controller that generated 109 * this command. We compare a copy of the trids, since the trids 110 * here don't contain the subnqn, and the transport_id_compare() 111 * function will compare the subnqns. 112 */ 113 source_trid.subnqn[0] = '\0'; 114 listener_trid.subnqn[0] = '\0'; 115 if (!spdk_nvme_transport_id_compare(&listener_trid, &source_trid)) { 116 continue; 117 } 118 } 119 120 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_TYPE) != 0 && 121 !nvmf_discovery_compare_trtype(listener->trid, cmd_source_trid)) { 122 SPDK_DEBUGLOG(nvmf, "ignore listener type %d (%s) due to type mismatch\n", 123 listener->trid->trtype, listener->trid->trstring); 124 continue; 125 } 126 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_ADDRESS) != 0 && 127 !nvmf_discovery_compare_tr_addr(listener->trid, cmd_source_trid)) { 128 SPDK_DEBUGLOG(nvmf, "ignore listener addr %s due to addr mismatch\n", 129 listener->trid->traddr); 130 continue; 131 } 132 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_SVCID) != 0 && 133 !nvmf_discovery_compare_tr_svcid(listener->trid, cmd_source_trid)) { 134 SPDK_DEBUGLOG(nvmf, "ignore listener svcid %s due to svcid mismatch\n", 135 listener->trid->trsvcid); 136 continue; 137 } 138 139 SPDK_DEBUGLOG(nvmf, "listener %s:%s trtype %s\n", listener->trid->traddr, listener->trid->trsvcid, 140 listener->trid->trstring); 141 142 size_t new_size = cur_size + sizeof(*entry); 143 void *new_log_page = realloc(disc_log, new_size); 144 145 if (new_log_page == NULL) { 146 SPDK_ERRLOG("Discovery log page memory allocation error\n"); 147 break; 148 } 149 150 disc_log = new_log_page; 151 cur_size = new_size; 152 153 entry = &disc_log->entries[numrec]; 154 memset(entry, 0, sizeof(*entry)); 155 entry->portid = listener->id; 156 entry->cntlid = 0xffff; 157 entry->asqsz = listener->transport->opts.max_aq_depth; 158 entry->subtype = subsystem->subtype; 159 snprintf(entry->subnqn, sizeof(entry->subnqn), "%s", subsystem->subnqn); 160 161 nvmf_transport_listener_discover(listener->transport, listener->trid, entry); 162 163 numrec++; 164 } 165 } 166 167 disc_log->numrec = numrec; 168 disc_log->genctr = tgt->discovery_genctr; 169 *log_page_size = cur_size; 170 171 return disc_log; 172 } 173 174 void 175 nvmf_get_discovery_log_page(struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov, 176 uint32_t iovcnt, uint64_t offset, uint32_t length, 177 struct spdk_nvme_transport_id *cmd_source_trid) 178 { 179 size_t copy_len = 0; 180 size_t zero_len = 0; 181 struct iovec *tmp; 182 size_t log_page_size = 0; 183 struct spdk_nvmf_discovery_log_page *discovery_log_page; 184 185 discovery_log_page = nvmf_generate_discovery_log(tgt, hostnqn, &log_page_size, cmd_source_trid); 186 187 /* Copy the valid part of the discovery log page, if any */ 188 if (discovery_log_page) { 189 for (tmp = iov; tmp < iov + iovcnt; tmp++) { 190 copy_len = spdk_min(tmp->iov_len, length); 191 copy_len = spdk_min(log_page_size - offset, copy_len); 192 193 memcpy(tmp->iov_base, (char *)discovery_log_page + offset, copy_len); 194 195 offset += copy_len; 196 length -= copy_len; 197 zero_len = tmp->iov_len - copy_len; 198 if (log_page_size <= offset || length == 0) { 199 break; 200 } 201 } 202 /* Zero out the rest of the payload */ 203 if (zero_len) { 204 memset((char *)tmp->iov_base + copy_len, 0, zero_len); 205 } 206 207 for (++tmp; tmp < iov + iovcnt; tmp++) { 208 memset((char *)tmp->iov_base, 0, tmp->iov_len); 209 } 210 211 free(discovery_log_page); 212 } 213 } 214