ceph/src/spdk/lib/nvmf/transport.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) Intel Corporation.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "spdk/stdinc.h"
  35
  36 #include "nvmf_internal.h"
  37 #include "transport.h"
  38
  39 #include "spdk/config.h"
  40 #include "spdk/log.h"
  41 #include "spdk/nvmf.h"
  42 #include "spdk/queue.h"
  43 #include "spdk/util.h"
  44
  45 static const struct spdk_nvmf_transport_ops *const g_transport_ops[] = {
  46 #ifdef SPDK_CONFIG_RDMA
  47         &spdk_nvmf_transport_rdma,
  48 #endif
  49 };
  50
  51 #define NUM_TRANSPORTS (SPDK_COUNTOF(g_transport_ops))
  52
  53 static inline const struct spdk_nvmf_transport_ops *
  54 spdk_nvmf_get_transport_ops(enum spdk_nvme_transport_type type)
  55 {
  56         size_t i;
  57         for (i = 0; i != NUM_TRANSPORTS; i++) {
  58                 if (g_transport_ops[i]->type == type) {
  59                         return g_transport_ops[i];
  60                 }
  61         }
  62         return NULL;
  63 }
  64
  65 struct spdk_nvmf_transport *
  66 spdk_nvmf_transport_create(enum spdk_nvme_transport_type type,
  67                            struct spdk_nvmf_transport_opts *opts)
  68 {
  69         const struct spdk_nvmf_transport_ops *ops = NULL;
  70         struct spdk_nvmf_transport *transport;
  71
  72         if ((opts->max_io_size % opts->io_unit_size != 0) ||
  73             (opts->max_io_size / opts->io_unit_size >
  74              SPDK_NVMF_MAX_SGL_ENTRIES)) {
  75                 SPDK_ERRLOG("%s: invalid IO size, MaxIO:%d, UnitIO:%d, MaxSGL:%d\n",
  76                             spdk_nvme_transport_id_trtype_str(type),
  77                             opts->max_io_size,
  78                             opts->io_unit_size,
  79                             SPDK_NVMF_MAX_SGL_ENTRIES);
  80                 return NULL;
  81         }
  82
  83         ops = spdk_nvmf_get_transport_ops(type);
  84         if (!ops) {
  85                 SPDK_ERRLOG("Transport type %s unavailable.\n",
  86                             spdk_nvme_transport_id_trtype_str(type));
  87                 return NULL;
  88         }
  89
  90         transport = ops->create(opts);
  91         if (!transport) {
  92                 SPDK_ERRLOG("Unable to create new transport of type %s\n",
  93                             spdk_nvme_transport_id_trtype_str(type));
  94                 return NULL;
  95         }
  96
  97         transport->ops = ops;
  98         transport->opts = *opts;
  99
 100         return transport;
 101 }
 102
 103 int
 104 spdk_nvmf_transport_destroy(struct spdk_nvmf_transport *transport)
 105 {
 106         return transport->ops->destroy(transport);
 107 }
 108
 109 int
 110 spdk_nvmf_transport_listen(struct spdk_nvmf_transport *transport,
 111                            const struct spdk_nvme_transport_id *trid)
 112 {
 113         return transport->ops->listen(transport, trid);
 114 }
 115
 116 int
 117 spdk_nvmf_transport_stop_listen(struct spdk_nvmf_transport *transport,
 118                                 const struct spdk_nvme_transport_id *trid)
 119 {
 120         return transport->ops->stop_listen(transport, trid);
 121 }
 122
 123 void
 124 spdk_nvmf_transport_accept(struct spdk_nvmf_transport *transport, new_qpair_fn cb_fn)
 125 {
 126         transport->ops->accept(transport, cb_fn);
 127 }
 128
 129 void
 130 spdk_nvmf_transport_listener_discover(struct spdk_nvmf_transport *transport,
 131                                       struct spdk_nvme_transport_id *trid,
 132                                       struct spdk_nvmf_discovery_log_page_entry *entry)
 133 {
 134         transport->ops->listener_discover(transport, trid, entry);
 135 }
 136
 137 struct spdk_nvmf_transport_poll_group *
 138 spdk_nvmf_transport_poll_group_create(struct spdk_nvmf_transport *transport)
 139 {
 140         struct spdk_nvmf_transport_poll_group *group;
 141
 142         group = transport->ops->poll_group_create(transport);
 143         group->transport = transport;
 144
 145         return group;
 146 }
 147
 148 void
 149 spdk_nvmf_transport_poll_group_destroy(struct spdk_nvmf_transport_poll_group *group)
 150 {
 151         group->transport->ops->poll_group_destroy(group);
 152 }
 153
 154 int
 155 spdk_nvmf_transport_poll_group_add(struct spdk_nvmf_transport_poll_group *group,
 156                                    struct spdk_nvmf_qpair *qpair)
 157 {
 158         if (qpair->transport) {
 159                 assert(qpair->transport == group->transport);
 160                 if (qpair->transport != group->transport) {
 161                         return -1;
 162                 }
 163         } else {
 164                 qpair->transport = group->transport;
 165         }
 166
 167         return group->transport->ops->poll_group_add(group, qpair);
 168 }
 169
 170 int
 171 spdk_nvmf_transport_poll_group_poll(struct spdk_nvmf_transport_poll_group *group)
 172 {
 173         return group->transport->ops->poll_group_poll(group);
 174 }
 175
 176 int
 177 spdk_nvmf_transport_req_free(struct spdk_nvmf_request *req)
 178 {
 179         return req->qpair->transport->ops->req_free(req);
 180 }
 181
 182 int
 183 spdk_nvmf_transport_req_complete(struct spdk_nvmf_request *req)
 184 {
 185         return req->qpair->transport->ops->req_complete(req);
 186 }
 187
 188 void
 189 spdk_nvmf_transport_qpair_fini(struct spdk_nvmf_qpair *qpair)
 190 {
 191         qpair->transport->ops->qpair_fini(qpair);
 192 }
 193
 194 bool
 195 spdk_nvmf_transport_qpair_is_idle(struct spdk_nvmf_qpair *qpair)
 196 {
 197         return qpair->transport->ops->qpair_is_idle(qpair);
 198 }
 199
 200 int
 201 spdk_nvmf_transport_qpair_get_peer_trid(struct spdk_nvmf_qpair *qpair,
 202                                         struct spdk_nvme_transport_id *trid)
 203 {
 204         return qpair->transport->ops->qpair_get_peer_trid(qpair, trid);
 205 }
 206
 207 int
 208 spdk_nvmf_transport_qpair_get_local_trid(struct spdk_nvmf_qpair *qpair,
 209                 struct spdk_nvme_transport_id *trid)
 210 {
 211         return qpair->transport->ops->qpair_get_local_trid(qpair, trid);
 212 }
 213
 214 int
 215 spdk_nvmf_transport_qpair_get_listen_trid(struct spdk_nvmf_qpair *qpair,
 216                 struct spdk_nvme_transport_id *trid)
 217 {
 218         return qpair->transport->ops->qpair_get_listen_trid(qpair, trid);
 219 }
 220
 221 bool
 222 spdk_nvmf_transport_opts_init(enum spdk_nvme_transport_type type,
 223                               struct spdk_nvmf_transport_opts *opts)
 224 {
 225         const struct spdk_nvmf_transport_ops *ops;
 226
 227         ops = spdk_nvmf_get_transport_ops(type);
 228         if (!ops) {
 229                 SPDK_ERRLOG("Transport type %s unavailable.\n",
 230                             spdk_nvme_transport_id_trtype_str(type));
 231                 return false;
 232         }
 233
 234         ops->opts_init(opts);
 235         return true;
 236 }