From 84d904841f2557c14d9f489df87340d7d51cde6e Mon Sep 17 00:00:00 2001 From: Daniel Verkamp Date: Thu, 2 Feb 2017 10:07:12 -0700 Subject: [PATCH] util: move common helper functions to util.h These were repeated a few different places, so pull them into a common header file. Change-Id: Id807fa2cfec0de2e0363aeb081510fb801781985 Signed-off-by: Daniel Verkamp --- app/nvmf_tgt/conf.c | 17 +++++----- include/spdk/nvmf.h | 3 -- include/spdk/util.h | 71 ++++++++++++++++++++++++++++++++++++++++ lib/ioat/ioat.c | 11 +++---- lib/nvme/nvme_ctrlr.c | 14 ++++---- lib/nvme/nvme_internal.h | 19 +---------- lib/nvme/nvme_ns_cmd.c | 2 +- lib/nvme/nvme_pcie.c | 14 ++++---- lib/nvme/nvme_rdma.c | 14 ++++---- lib/nvmf/nvmf_internal.h | 11 +------ lib/nvmf/rdma.c | 10 +++--- lib/nvmf/session.c | 2 +- lib/nvmf/subsystem.c | 2 +- lib/nvmf/virtual.c | 2 +- lib/util/bit_array.c | 3 +- 15 files changed, 119 insertions(+), 76 deletions(-) create mode 100644 include/spdk/util.h diff --git a/app/nvmf_tgt/conf.c b/app/nvmf_tgt/conf.c index 8315bce48..4eee2fa8c 100644 --- a/app/nvmf_tgt/conf.c +++ b/app/nvmf_tgt/conf.c @@ -51,6 +51,7 @@ #include "spdk/nvme.h" #include "spdk/nvmf.h" #include "spdk/string.h" +#include "spdk/util.h" #define MAX_LISTEN_ADDRESSES 255 #define MAX_HOSTS 255 @@ -176,15 +177,15 @@ spdk_nvmf_parse_nvmf_tgt(void) if (max_queue_depth < 0) { max_queue_depth = SPDK_NVMF_CONFIG_QUEUE_DEPTH_DEFAULT; } - max_queue_depth = nvmf_max(max_queue_depth, SPDK_NVMF_CONFIG_QUEUE_DEPTH_MIN); - max_queue_depth = nvmf_min(max_queue_depth, SPDK_NVMF_CONFIG_QUEUE_DEPTH_MAX); + max_queue_depth = spdk_max(max_queue_depth, SPDK_NVMF_CONFIG_QUEUE_DEPTH_MIN); + max_queue_depth = spdk_min(max_queue_depth, SPDK_NVMF_CONFIG_QUEUE_DEPTH_MAX); max_queues_per_sess = spdk_conf_section_get_intval(sp, "MaxQueuesPerSession"); if (max_queues_per_sess < 0) { max_queues_per_sess = SPDK_NVMF_CONFIG_QUEUES_PER_SESSION_DEFAULT; } - max_queues_per_sess = nvmf_max(max_queues_per_sess, SPDK_NVMF_CONFIG_QUEUES_PER_SESSION_MIN); - max_queues_per_sess = nvmf_min(max_queues_per_sess, SPDK_NVMF_CONFIG_QUEUES_PER_SESSION_MAX); + max_queues_per_sess = spdk_max(max_queues_per_sess, SPDK_NVMF_CONFIG_QUEUES_PER_SESSION_MIN); + max_queues_per_sess = spdk_min(max_queues_per_sess, SPDK_NVMF_CONFIG_QUEUES_PER_SESSION_MAX); in_capsule_data_size = spdk_conf_section_get_intval(sp, "InCapsuleDataSize"); if (in_capsule_data_size < 0) { @@ -193,8 +194,8 @@ spdk_nvmf_parse_nvmf_tgt(void) SPDK_ERRLOG("InCapsuleDataSize must be a multiple of 16\n"); return -1; } - in_capsule_data_size = nvmf_max(in_capsule_data_size, SPDK_NVMF_CONFIG_IN_CAPSULE_DATA_SIZE_MIN); - in_capsule_data_size = nvmf_min(in_capsule_data_size, SPDK_NVMF_CONFIG_IN_CAPSULE_DATA_SIZE_MAX); + in_capsule_data_size = spdk_max(in_capsule_data_size, SPDK_NVMF_CONFIG_IN_CAPSULE_DATA_SIZE_MIN); + in_capsule_data_size = spdk_min(in_capsule_data_size, SPDK_NVMF_CONFIG_IN_CAPSULE_DATA_SIZE_MAX); max_io_size = spdk_conf_section_get_intval(sp, "MaxIOSize"); if (max_io_size < 0) { @@ -203,8 +204,8 @@ spdk_nvmf_parse_nvmf_tgt(void) SPDK_ERRLOG("MaxIOSize must be a multiple of 4096\n"); return -1; } - max_io_size = nvmf_max(max_io_size, SPDK_NVMF_CONFIG_MAX_IO_SIZE_MIN); - max_io_size = nvmf_min(max_io_size, SPDK_NVMF_CONFIG_MAX_IO_SIZE_MAX); + max_io_size = spdk_max(max_io_size, SPDK_NVMF_CONFIG_MAX_IO_SIZE_MIN); + max_io_size = spdk_min(max_io_size, SPDK_NVMF_CONFIG_MAX_IO_SIZE_MAX); acceptor_lcore = spdk_conf_section_get_intval(sp, "AcceptorCore"); if (acceptor_lcore < 0) { diff --git a/include/spdk/nvmf.h b/include/spdk/nvmf.h index a9e9ad9da..e2c86b0ae 100644 --- a/include/spdk/nvmf.h +++ b/include/spdk/nvmf.h @@ -47,9 +47,6 @@ #define MAX_VIRTUAL_NAMESPACE 16 #define MAX_SN_LEN 20 -#define nvmf_min(a,b) (((a)<(b))?(a):(b)) -#define nvmf_max(a,b) (((a)>(b))?(a):(b)) - int spdk_nvmf_tgt_init(uint16_t max_queue_depth, uint16_t max_conn_per_sess, uint32_t in_capsule_data_size, uint32_t max_io_size); diff --git a/include/spdk/util.h b/include/spdk/util.h new file mode 100644 index 000000000..952fa53cc --- /dev/null +++ b/include/spdk/util.h @@ -0,0 +1,71 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** \file + * General utility functions + */ + +#ifndef SPDK_UTIL_H +#define SPDK_UTIL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#define spdk_min(a,b) (((a)<(b))?(a):(b)) +#define spdk_max(a,b) (((a)>(b))?(a):(b)) + +static inline uint32_t +spdk_u32log2(uint32_t x) +{ + if (x == 0) { + /* log(0) is undefined */ + return 0; + } + return 31u - __builtin_clz(x); +} + +static inline uint32_t +spdk_align32pow2(uint32_t x) +{ + return 1u << (1 + spdk_u32log2(x - 1)); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/ioat/ioat.c b/lib/ioat/ioat.c index 97189d014..9e6feac62 100644 --- a/lib/ioat/ioat.c +++ b/lib/ioat/ioat.c @@ -34,6 +34,7 @@ #include "ioat_internal.h" #include "spdk/env.h" +#include "spdk/util.h" #include "spdk_internal/log.h" @@ -569,8 +570,6 @@ spdk_ioat_detach(struct spdk_ioat_chan *ioat) return 0; } -#define min(a, b) (((a)<(b))?(a):(b)) - #define _2MB_PAGE(ptr) ((ptr) & ~(0x200000 - 1)) #define _2MB_OFFSET(ptr) ((ptr) & (0x200000 - 1)) @@ -608,9 +607,9 @@ spdk_ioat_submit_copy(struct spdk_ioat_chan *ioat, void *cb_arg, spdk_ioat_req_c pdst_page = spdk_vtophys((void *)vdst_page); } op_size = remaining; - op_size = min(op_size, (0x200000 - _2MB_OFFSET(vsrc))); - op_size = min(op_size, (0x200000 - _2MB_OFFSET(vdst))); - op_size = min(op_size, ioat->max_xfer_size); + op_size = spdk_min(op_size, (0x200000 - _2MB_OFFSET(vsrc))); + op_size = spdk_min(op_size, (0x200000 - _2MB_OFFSET(vdst))); + op_size = spdk_min(op_size, ioat->max_xfer_size); remaining -= op_size; last_desc = ioat_prep_copy(ioat, @@ -672,7 +671,7 @@ spdk_ioat_submit_fill(struct spdk_ioat_chan *ioat, void *cb_arg, spdk_ioat_req_c while (remaining) { op_size = remaining; - op_size = min(op_size, ioat->max_xfer_size); + op_size = spdk_min(op_size, ioat->max_xfer_size); remaining -= op_size; last_desc = ioat_prep_fill(ioat, diff --git a/lib/nvme/nvme_ctrlr.c b/lib/nvme/nvme_ctrlr.c index eeea4b295..599359114 100644 --- a/lib/nvme/nvme_ctrlr.c +++ b/lib/nvme/nvme_ctrlr.c @@ -432,7 +432,7 @@ nvme_ctrlr_enable(struct spdk_nvme_ctrlr *ctrlr) cc.bits.iocqes = 4; /* CQ entry size == 16 == 2^4 */ /* Page size is 2 ^ (12 + mps). */ - cc.bits.mps = nvme_u32log2(PAGE_SIZE) - 12; + cc.bits.mps = spdk_u32log2(PAGE_SIZE) - 12; switch (ctrlr->opts.arb_mechanism) { case SPDK_NVME_CC_AMS_RR: @@ -582,7 +582,7 @@ nvme_ctrlr_identify(struct spdk_nvme_ctrlr *ctrlr) ctrlr->max_xfer_size = nvme_transport_ctrlr_get_max_xfer_size(ctrlr); SPDK_TRACELOG(SPDK_TRACE_NVME, "transport max_xfer_size %u\n", ctrlr->max_xfer_size); if (ctrlr->cdata.mdts > 0) { - ctrlr->max_xfer_size = nvme_min(ctrlr->max_xfer_size, + ctrlr->max_xfer_size = spdk_min(ctrlr->max_xfer_size, ctrlr->min_page_size * (1 << (ctrlr->cdata.mdts))); SPDK_TRACELOG(SPDK_TRACE_NVME, "MDTS max_xfer_size %u\n", ctrlr->max_xfer_size); } @@ -631,7 +631,7 @@ nvme_ctrlr_set_num_qpairs(struct spdk_nvme_ctrlr *ctrlr) sq_allocated = (status.cpl.cdw0 & 0xFFFF) + 1; cq_allocated = (status.cpl.cdw0 >> 16) + 1; - ctrlr->opts.num_io_queues = nvme_min(sq_allocated, cq_allocated); + ctrlr->opts.num_io_queues = spdk_min(sq_allocated, cq_allocated); ctrlr->free_io_qids = spdk_bit_array_create(ctrlr->opts.num_io_queues + 1); if (ctrlr->free_io_qids == NULL) { @@ -851,7 +851,7 @@ nvme_ctrlr_configure_aer(struct spdk_nvme_ctrlr *ctrlr) } /* aerl is a zero-based value, so we need to add 1 here. */ - ctrlr->num_aers = nvme_min(NVME_MAX_ASYNC_EVENTS, (ctrlr->cdata.aerl + 1)); + ctrlr->num_aers = spdk_min(NVME_MAX_ASYNC_EVENTS, (ctrlr->cdata.aerl + 1)); for (i = 0; i < ctrlr->num_aers; i++) { aer = &ctrlr->aer[i]; @@ -1312,8 +1312,8 @@ nvme_ctrlr_init_cap(struct spdk_nvme_ctrlr *ctrlr, const union spdk_nvme_cap_reg ctrlr->min_page_size = 1u << (12 + ctrlr->cap.bits.mpsmin); - ctrlr->opts.io_queue_size = nvme_min(ctrlr->opts.io_queue_size, ctrlr->cap.bits.mqes + 1u); - ctrlr->opts.io_queue_size = nvme_min(ctrlr->opts.io_queue_size, max_io_queue_size); + ctrlr->opts.io_queue_size = spdk_min(ctrlr->opts.io_queue_size, ctrlr->cap.bits.mqes + 1u); + ctrlr->opts.io_queue_size = spdk_min(ctrlr->opts.io_queue_size, max_io_queue_size); } void @@ -1628,7 +1628,7 @@ spdk_nvme_ctrlr_update_firmware(struct spdk_nvme_ctrlr *ctrlr, void *payload, ui p = payload; while (size_remaining > 0) { - transfer = nvme_min(size_remaining, ctrlr->min_page_size); + transfer = spdk_min(size_remaining, ctrlr->min_page_size); status.done = false; res = nvme_ctrlr_cmd_fw_image_download(ctrlr, transfer, offset, p, diff --git a/lib/nvme/nvme_internal.h b/lib/nvme/nvme_internal.h index 7e7d593dc..f1ef3eb6f 100644 --- a/lib/nvme/nvme_internal.h +++ b/lib/nvme/nvme_internal.h @@ -55,6 +55,7 @@ #include "spdk/bit_array.h" #include "spdk/mmio.h" #include "spdk/pci_ids.h" +#include "spdk/util.h" #include "spdk/nvme_intel.h" #include "spdk/nvmf_spec.h" @@ -427,26 +428,8 @@ struct nvme_driver { extern struct nvme_driver *g_spdk_nvme_driver; -#define nvme_min(a,b) (((a)<(b))?(a):(b)) - #define nvme_delay usleep -static inline uint32_t -nvme_u32log2(uint32_t x) -{ - if (x == 0) { - /* __builtin_clz(0) is undefined, so just bail */ - return 0; - } - return 31u - __builtin_clz(x); -} - -static inline uint32_t -nvme_align32pow2(uint32_t x) -{ - return 1u << (1 + nvme_u32log2(x - 1)); -} - static inline bool nvme_qpair_is_admin_queue(struct spdk_nvme_qpair *qpair) { diff --git a/lib/nvme/nvme_ns_cmd.c b/lib/nvme/nvme_ns_cmd.c index 7b8d4a0d9..2aa6afdcf 100644 --- a/lib/nvme/nvme_ns_cmd.c +++ b/lib/nvme/nvme_ns_cmd.c @@ -153,7 +153,7 @@ _nvme_ns_cmd_split_request(struct spdk_nvme_ns *ns, while (remaining_lba_count > 0) { lba_count = sectors_per_max_io - (lba & sector_mask); - lba_count = nvme_min(remaining_lba_count, lba_count); + lba_count = spdk_min(remaining_lba_count, lba_count); child = _nvme_add_child_request(ns, payload, payload_offset, md_offset, lba, lba_count, cb_fn, cb_arg, opc, diff --git a/lib/nvme/nvme_pcie.c b/lib/nvme/nvme_pcie.c index 36f87be02..681dcaf98 100644 --- a/lib/nvme/nvme_pcie.c +++ b/lib/nvme/nvme_pcie.c @@ -836,7 +836,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair) * Note also that for a queue size of N, we can only have (N-1) * commands outstanding, hence the "-1" here. */ - num_trackers = nvme_min(NVME_IO_TRACKERS, pqpair->num_entries - 1); + num_trackers = spdk_min(NVME_IO_TRACKERS, pqpair->num_entries - 1); } assert(num_trackers != 0); @@ -1512,11 +1512,11 @@ nvme_pcie_qpair_build_contig_request(struct spdk_nvme_qpair *qpair, struct nvme_ nvme_pcie_fail_request_bad_vtophys(qpair, tr); return -1; } - nseg = req->payload_size >> nvme_u32log2(PAGE_SIZE); + nseg = req->payload_size >> spdk_u32log2(PAGE_SIZE); modulo = req->payload_size & (PAGE_SIZE - 1); unaligned = phys_addr & (PAGE_SIZE - 1); if (modulo || unaligned) { - nseg += 1 + ((modulo + unaligned - 1) >> nvme_u32log2(PAGE_SIZE)); + nseg += 1 + ((modulo + unaligned - 1) >> spdk_u32log2(PAGE_SIZE)); } if (req->payload.md) { @@ -1598,7 +1598,7 @@ nvme_pcie_qpair_build_hw_sgl_request(struct spdk_nvme_qpair *qpair, struct nvme_ return -1; } - length = nvme_min(remaining_transfer_len, length); + length = spdk_min(remaining_transfer_len, length); remaining_transfer_len -= length; sgl->unkeyed.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; @@ -1680,13 +1680,13 @@ nvme_pcie_qpair_build_prps_sgl_request(struct spdk_nvme_qpair *qpair, struct nvm /* All SGe except first must start on a page boundary. */ assert((sge_count == 0) || _is_page_aligned(phys_addr)); - data_transferred = nvme_min(remaining_transfer_len, length); + data_transferred = spdk_min(remaining_transfer_len, length); - nseg = data_transferred >> nvme_u32log2(PAGE_SIZE); + nseg = data_transferred >> spdk_u32log2(PAGE_SIZE); modulo = data_transferred & (PAGE_SIZE - 1); unaligned = phys_addr & (PAGE_SIZE - 1); if (modulo || unaligned) { - nseg += 1 + ((modulo + unaligned - 1) >> nvme_u32log2(PAGE_SIZE)); + nseg += 1 + ((modulo + unaligned - 1) >> spdk_u32log2(PAGE_SIZE)); } if (total_nseg == 0) { diff --git a/lib/nvme/nvme_rdma.c b/lib/nvme/nvme_rdma.c index c26ef139d..ac9d8480f 100644 --- a/lib/nvme/nvme_rdma.c +++ b/lib/nvme/nvme_rdma.c @@ -479,7 +479,7 @@ nvme_rdma_copy_mem(struct spdk_nvme_rdma_req *rdma_req, bool copy_from_user) return -1; } - len = nvme_min(remaining_transfer_len, len); + len = spdk_min(remaining_transfer_len, len); remaining_transfer_len -= len; if (copy_from_user) { @@ -592,7 +592,7 @@ nvme_rdma_connect(struct nvme_rdma_qpair *rqpair) return ret; } - param.responder_resources = nvme_min(rqpair->num_entries, attr.max_qp_rd_atom); + param.responder_resources = spdk_min(rqpair->num_entries, attr.max_qp_rd_atom); ctrlr = rqpair->qpair.ctrlr; if (!ctrlr) { @@ -631,7 +631,7 @@ nvme_rdma_connect(struct nvme_rdma_qpair *rqpair) SPDK_TRACELOG(SPDK_TRACE_NVME, "Requested queue depth %d. Actually got queue depth %d.\n", rqpair->num_entries, accept_data->crqsize); - rqpair->num_entries = nvme_min(rqpair->num_entries , accept_data->crqsize); + rqpair->num_entries = spdk_min(rqpair->num_entries, accept_data->crqsize); rdma_ack_cm_event(event); @@ -1178,7 +1178,7 @@ nvme_rdma_ctrlr_scan(const struct spdk_nvme_transport_id *discovery_trid, */ buffer_max_entries = (sizeof(buffer) - offsetof(struct spdk_nvmf_discovery_log_page, entries[0])) / sizeof(struct spdk_nvmf_discovery_log_page_entry); - numrec = nvme_min(log_page->numrec, buffer_max_entries); + numrec = spdk_min(log_page->numrec, buffer_max_entries); if (numrec != log_page->numrec) { SPDK_WARNLOG("Discovery service returned %" PRIu64 " entries," "but buffer can only hold %" PRIu64 "\n", @@ -1382,13 +1382,13 @@ nvme_rdma_qpair_process_completions(struct spdk_nvme_qpair *qpair, if (max_completions == 0) { max_completions = rqpair->num_entries; } else { - max_completions = nvme_min(max_completions, rqpair->num_entries); + max_completions = spdk_min(max_completions, rqpair->num_entries); } /* Consume all send completions */ reaped = 0; do { - batch_size = nvme_min((max_completions - reaped), + batch_size = spdk_min((max_completions - reaped), MAX_COMPLETIONS_PER_POLL); rc = ibv_poll_cq(rqpair->cm_id->send_cq, batch_size, wc); if (rc < 0) { @@ -1405,7 +1405,7 @@ nvme_rdma_qpair_process_completions(struct spdk_nvme_qpair *qpair, /* Poll for recv completions */ reaped = 0; do { - batch_size = nvme_min((max_completions - reaped), + batch_size = spdk_min((max_completions - reaped), MAX_COMPLETIONS_PER_POLL); rc = ibv_poll_cq(rqpair->cm_id->recv_cq, batch_size, wc); if (rc < 0) { diff --git a/lib/nvmf/nvmf_internal.h b/lib/nvmf/nvmf_internal.h index 56824d740..5c2b0b854 100644 --- a/lib/nvmf/nvmf_internal.h +++ b/lib/nvmf/nvmf_internal.h @@ -42,6 +42,7 @@ #include "spdk/nvmf_spec.h" #include "spdk/assert.h" #include "spdk/queue.h" +#include "spdk/util.h" #define SPDK_NVMF_DEFAULT_NUM_SESSIONS_PER_LCORE 1 @@ -53,16 +54,6 @@ struct spdk_nvmf_tgt { uint32_t max_io_size; }; -static inline uint32_t -nvmf_u32log2(uint32_t x) -{ - if (x == 0) { - /* __builtin_clz(0) is undefined, so just bail */ - return 0; - } - return 31u - __builtin_clz(x); -} - extern struct spdk_nvmf_tgt g_nvmf_tgt; struct spdk_nvmf_listen_addr *spdk_nvmf_listen_addr_create(const char *trname, const char *traddr, diff --git a/lib/nvmf/rdma.c b/lib/nvmf/rdma.c index fc5eaca42..af655a476 100644 --- a/lib/nvmf/rdma.c +++ b/lib/nvmf/rdma.c @@ -675,15 +675,15 @@ nvmf_rdma_connect(struct rdma_cm_event *event) SPDK_TRACELOG(SPDK_TRACE_RDMA, "Local NIC Max Send/Recv Queue Depth: %d Max Read/Write Queue Depth: %d\n", addr->attr.max_qp_wr, addr->attr.max_qp_rd_atom); - max_queue_depth = nvmf_min(max_queue_depth, addr->attr.max_qp_wr); - max_rw_depth = nvmf_min(max_rw_depth, addr->attr.max_qp_rd_atom); + max_queue_depth = spdk_min(max_queue_depth, addr->attr.max_qp_wr); + max_rw_depth = spdk_min(max_rw_depth, addr->attr.max_qp_rd_atom); /* Next check the remote NIC's hardware limitations */ SPDK_TRACELOG(SPDK_TRACE_RDMA, "Host (Initiator) NIC Max Incoming RDMA R/W operations: %d Max Outgoing RDMA R/W operations: %d\n", rdma_param->initiator_depth, rdma_param->responder_resources); if (rdma_param->initiator_depth > 0) { - max_rw_depth = nvmf_min(max_rw_depth, rdma_param->initiator_depth); + max_rw_depth = spdk_min(max_rw_depth, rdma_param->initiator_depth); } /* Finally check for the host software requested values, which are @@ -692,8 +692,8 @@ nvmf_rdma_connect(struct rdma_cm_event *event) rdma_param->private_data_len >= sizeof(struct spdk_nvmf_rdma_request_private_data)) { SPDK_TRACELOG(SPDK_TRACE_RDMA, "Host Receive Queue Size: %d\n", private_data->hrqsize); SPDK_TRACELOG(SPDK_TRACE_RDMA, "Host Send Queue Size: %d\n", private_data->hsqsize); - max_queue_depth = nvmf_min(max_queue_depth, private_data->hrqsize); - max_queue_depth = nvmf_min(max_queue_depth, private_data->hsqsize); + max_queue_depth = spdk_min(max_queue_depth, private_data->hrqsize); + max_queue_depth = spdk_min(max_queue_depth, private_data->hsqsize); } SPDK_TRACELOG(SPDK_TRACE_RDMA, "Final Negotiated Queue Depth: %d R/W Depth: %d\n", diff --git a/lib/nvmf/session.c b/lib/nvmf/session.c index 397e0a9d8..2e1f69272 100644 --- a/lib/nvmf/session.c +++ b/lib/nvmf/session.c @@ -99,7 +99,7 @@ nvmf_init_nvme_session_properties(struct spdk_nvmf_session *session) session->vcdata.cntlid = session->cntlid; session->vcdata.kas = 10; session->vcdata.maxcmd = g_nvmf_tgt.max_queue_depth; - session->vcdata.mdts = nvmf_u32log2(g_nvmf_tgt.max_io_size / 4096); + session->vcdata.mdts = spdk_u32log2(g_nvmf_tgt.max_io_size / 4096); session->vcdata.sgls.keyed_sgl = 1; session->vcdata.sgls.sgl_offset = 1; diff --git a/lib/nvmf/subsystem.c b/lib/nvmf/subsystem.c index 5c12a874d..894a80118 100644 --- a/lib/nvmf/subsystem.c +++ b/lib/nvmf/subsystem.c @@ -395,7 +395,7 @@ spdk_nvmf_get_discovery_log_page(void *buffer, uint64_t offset, uint32_t length) /* Copy the valid part of the discovery log page, if any */ if (g_discovery_log_page && offset < g_discovery_log_page_size) { - copy_len = nvmf_min(g_discovery_log_page_size - offset, length); + copy_len = spdk_min(g_discovery_log_page_size - offset, length); zero_len -= copy_len; memcpy(buffer, (char *)g_discovery_log_page + offset, copy_len); } diff --git a/lib/nvmf/virtual.c b/lib/nvmf/virtual.c index b15f76dc8..8933451e3 100644 --- a/lib/nvmf/virtual.c +++ b/lib/nvmf/virtual.c @@ -196,7 +196,7 @@ identify_ns(struct spdk_nvmf_subsystem *subsystem, nsdata->nuse = bdev->blockcnt; nsdata->nlbaf = 0; nsdata->flbas.format = 0; - nsdata->lbaf[0].lbads = nvmf_u32log2(bdev->blocklen); + nsdata->lbaf[0].lbads = spdk_u32log2(bdev->blocklen); return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE; } diff --git a/lib/util/bit_array.c b/lib/util/bit_array.c index 6019a8544..5b90aa152 100644 --- a/lib/util/bit_array.c +++ b/lib/util/bit_array.c @@ -43,13 +43,14 @@ #include #include "spdk/likely.h" +#include "spdk/util.h" typedef uint64_t spdk_bit_array_word; #define SPDK_BIT_ARRAY_WORD_TZCNT(x) (__builtin_ctzll(x)) #define SPDK_BIT_ARRAY_WORD_C(x) ((spdk_bit_array_word)(x)) #define SPDK_BIT_ARRAY_WORD_BYTES sizeof(spdk_bit_array_word) #define SPDK_BIT_ARRAY_WORD_BITS (SPDK_BIT_ARRAY_WORD_BYTES * 8) -#define SPDK_BIT_ARRAY_WORD_INDEX_SHIFT (31u - __builtin_clz(SPDK_BIT_ARRAY_WORD_BITS)) +#define SPDK_BIT_ARRAY_WORD_INDEX_SHIFT spdk_u32log2(SPDK_BIT_ARRAY_WORD_BITS) #define SPDK_BIT_ARRAY_WORD_INDEX_MASK ((1u << SPDK_BIT_ARRAY_WORD_INDEX_SHIFT) - 1) struct spdk_bit_array {