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 78 SPDK_DEBUGLOG(nvmf, "Generating log page for genctr %" PRIu64 "\n", 79 tgt->discovery_genctr); 80 81 cur_size = sizeof(struct spdk_nvmf_discovery_log_page); 82 disc_log = calloc(1, cur_size); 83 if (disc_log == NULL) { 84 SPDK_ERRLOG("Discovery log page memory allocation error\n"); 85 return NULL; 86 } 87 88 for (subsystem = spdk_nvmf_subsystem_get_first(tgt); 89 subsystem != NULL; 90 subsystem = spdk_nvmf_subsystem_get_next(subsystem)) { 91 if ((subsystem->state == SPDK_NVMF_SUBSYSTEM_INACTIVE) || 92 (subsystem->state == SPDK_NVMF_SUBSYSTEM_DEACTIVATING)) { 93 continue; 94 } 95 96 if (!spdk_nvmf_subsystem_host_allowed(subsystem, hostnqn)) { 97 continue; 98 } 99 100 for (listener = spdk_nvmf_subsystem_get_first_listener(subsystem); listener != NULL; 101 listener = spdk_nvmf_subsystem_get_next_listener(subsystem, listener)) { 102 if (subsystem->subtype == SPDK_NVMF_SUBTYPE_DISCOVERY) { 103 struct spdk_nvme_transport_id source_trid = *cmd_source_trid; 104 struct spdk_nvme_transport_id listener_trid = *listener->trid; 105 106 /* Do not generate an entry for the transport ID for the listener 107 * entry associated with the discovery controller that generated 108 * this command. We compare a copy of the trids, since the trids 109 * here don't contain the subnqn, and the transport_id_compare() 110 * function will compare the subnqns. 111 */ 112 source_trid.subnqn[0] = '\0'; 113 listener_trid.subnqn[0] = '\0'; 114 if (!spdk_nvme_transport_id_compare(&listener_trid, &source_trid)) { 115 continue; 116 } 117 } 118 119 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_TYPE) != 0 && 120 !nvmf_discovery_compare_trtype(listener->trid, cmd_source_trid)) { 121 SPDK_DEBUGLOG(nvmf, "ignore listener type %d (%s) due to type mismatch\n", 122 listener->trid->trtype, listener->trid->trstring); 123 continue; 124 } 125 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_ADDRESS) != 0 && 126 !nvmf_discovery_compare_tr_addr(listener->trid, cmd_source_trid)) { 127 SPDK_DEBUGLOG(nvmf, "ignore listener addr %s due to addr mismatch\n", 128 listener->trid->traddr); 129 continue; 130 } 131 if ((tgt->discovery_filter & SPDK_NVMF_TGT_DISCOVERY_MATCH_TRANSPORT_SVCID) != 0 && 132 !nvmf_discovery_compare_tr_svcid(listener->trid, cmd_source_trid)) { 133 SPDK_DEBUGLOG(nvmf, "ignore listener svcid %s due to svcid mismatch\n", 134 listener->trid->trsvcid); 135 continue; 136 } 137 138 SPDK_DEBUGLOG(nvmf, "listener %s:%s trtype %s\n", listener->trid->traddr, listener->trid->trsvcid, 139 listener->trid->trstring); 140 141 size_t new_size = cur_size + sizeof(*entry); 142 void *new_log_page = realloc(disc_log, new_size); 143 144 if (new_log_page == NULL) { 145 SPDK_ERRLOG("Discovery log page memory allocation error\n"); 146 break; 147 } 148 149 disc_log = new_log_page; 150 cur_size = new_size; 151 152 entry = &disc_log->entries[numrec]; 153 memset(entry, 0, sizeof(*entry)); 154 entry->portid = listener->id; 155 entry->cntlid = 0xffff; 156 entry->asqsz = listener->transport->opts.max_aq_depth; 157 entry->subtype = subsystem->subtype; 158 snprintf(entry->subnqn, sizeof(entry->subnqn), "%s", subsystem->subnqn); 159 160 nvmf_transport_listener_discover(listener->transport, listener->trid, entry); 161 162 numrec++; 163 } 164 } 165 166 disc_log->numrec = numrec; 167 disc_log->genctr = tgt->discovery_genctr; 168 *log_page_size = cur_size; 169 170 return disc_log; 171 } 172 173 void 174 nvmf_get_discovery_log_page(struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov, 175 uint32_t iovcnt, uint64_t offset, uint32_t length, 176 struct spdk_nvme_transport_id *cmd_source_trid) 177 { 178 size_t copy_len = 0; 179 size_t zero_len = 0; 180 struct iovec *tmp; 181 size_t log_page_size = 0; 182 struct spdk_nvmf_discovery_log_page *discovery_log_page; 183 184 discovery_log_page = nvmf_generate_discovery_log(tgt, hostnqn, &log_page_size, cmd_source_trid); 185 186 /* Copy the valid part of the discovery log page, if any */ 187 if (discovery_log_page) { 188 for (tmp = iov; tmp < iov + iovcnt; tmp++) { 189 copy_len = spdk_min(tmp->iov_len, length); 190 copy_len = spdk_min(log_page_size - offset, copy_len); 191 192 memcpy(tmp->iov_base, (char *)discovery_log_page + offset, copy_len); 193 194 offset += copy_len; 195 length -= copy_len; 196 zero_len = tmp->iov_len - copy_len; 197 if (log_page_size <= offset || length == 0) { 198 break; 199 } 200 } 201 /* Zero out the rest of the payload */ 202 if (zero_len) { 203 memset((char *)tmp->iov_base + copy_len, 0, zero_len); 204 } 205 206 for (++tmp; tmp < iov + iovcnt; tmp++) { 207 memset((char *)tmp->iov_base, 0, tmp->iov_len); 208 } 209 210 free(discovery_log_page); 211 } 212 } 213