int fi_ibv_check_tx_attr(const struct fi_tx_attr *attr, const struct fi_info *hints, const struct fi_info *info) { if (attr->caps & ~(info->tx_attr->caps)) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->caps not supported\n"); FI_INFO_CHECK(&fi_ibv_prov, (info->tx_attr), attr, caps, FI_TYPE_CAPS); return -FI_ENODATA; } if (((attr->mode ? attr->mode : hints->mode) & info->tx_attr->mode) != info->tx_attr->mode) { size_t user_mode = (attr->mode ? attr->mode : hints->mode); VERBS_INFO(FI_LOG_CORE, "Given tx_attr->mode not supported\n"); FI_INFO_MODE(&fi_ibv_prov, info->tx_attr->mode, user_mode); return -FI_ENODATA; } if (attr->op_flags & ~(info->tx_attr->op_flags)) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->op_flags not supported\n"); return -FI_ENODATA; } if (attr->msg_order & ~(info->tx_attr->msg_order)) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->msg_order not supported\n"); return -FI_ENODATA; } if (attr->size > info->tx_attr->size) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->size is greater than supported\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, (info->tx_attr), attr, size); return -FI_ENODATA; } if (attr->iov_limit > info->tx_attr->iov_limit) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->iov_limit greater than supported\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, (info->tx_attr), attr, iov_limit); return -FI_ENODATA; } if (attr->rma_iov_limit > info->tx_attr->rma_iov_limit) { VERBS_INFO(FI_LOG_CORE, "Given tx_attr->rma_iov_limit greater than supported\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, (info->tx_attr), attr, rma_iov_limit); return -FI_ENODATA; } return 0; }
int ofi_check_tx_attr(const struct fi_provider *prov, const struct fi_tx_attr *prov_attr, const struct fi_tx_attr *user_attr, uint64_t info_mode) { if (user_attr->caps & ~(prov_attr->caps)) { FI_INFO(prov, FI_LOG_CORE, "caps not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, caps, FI_TYPE_CAPS); return -FI_ENODATA; } info_mode = user_attr->mode ? user_attr->mode : info_mode; if ((info_mode & prov_attr->mode) != prov_attr->mode) { FI_INFO(prov, FI_LOG_CORE, "needed mode not set\n"); FI_INFO_MODE(prov, prov_attr->mode, user_attr->mode); return -FI_ENODATA; } if (prov_attr->op_flags & ~(prov_attr->op_flags)) { FI_INFO(prov, FI_LOG_CORE, "op_flags not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, op_flags, FI_TYPE_OP_FLAGS); return -FI_ENODATA; } if (user_attr->msg_order & ~(prov_attr->msg_order)) { FI_INFO(prov, FI_LOG_CORE, "msg_order not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, msg_order, FI_TYPE_MSG_ORDER); return -FI_ENODATA; } if (user_attr->comp_order & ~(prov_attr->comp_order)) { FI_INFO(prov, FI_LOG_CORE, "comp_order not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, comp_order, FI_TYPE_MSG_ORDER); return -FI_ENODATA; } if (user_attr->inject_size > prov_attr->inject_size) { FI_INFO(prov, FI_LOG_CORE, "inject_size too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, inject_size); return -FI_ENODATA; } if (user_attr->size > prov_attr->size) { FI_INFO(prov, FI_LOG_CORE, "size is greater than supported\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, size); return -FI_ENODATA; } if (user_attr->iov_limit > prov_attr->iov_limit) { FI_INFO(prov, FI_LOG_CORE, "iov_limit too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, iov_limit); return -FI_ENODATA; } if (user_attr->rma_iov_limit > prov_attr->rma_iov_limit) { FI_INFO(prov, FI_LOG_CORE, "rma_iov_limit too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, rma_iov_limit); return -FI_ENODATA; } return 0; }
int ofi_check_rx_attr(const struct fi_provider *prov, const struct fi_info *prov_info, const struct fi_rx_attr *user_attr, uint64_t info_mode) { const struct fi_rx_attr *prov_attr = prov_info->rx_attr; int rm_enabled = (prov_info->domain_attr->resource_mgmt == FI_RM_ENABLED); if (user_attr->caps & ~(prov_attr->caps)) { FI_INFO(prov, FI_LOG_CORE, "caps not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, caps, FI_TYPE_CAPS); return -FI_ENODATA; } info_mode = user_attr->mode ? user_attr->mode : info_mode; if ((info_mode & prov_attr->mode) != prov_attr->mode) { FI_INFO(prov, FI_LOG_CORE, "needed mode not set\n"); FI_INFO_MODE(prov, prov_attr->mode, user_attr->mode); return -FI_ENODATA; } if (prov_attr->op_flags & ~(prov_attr->op_flags)) { FI_INFO(prov, FI_LOG_CORE, "op_flags not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, op_flags, FI_TYPE_OP_FLAGS); return -FI_ENODATA; } if (user_attr->msg_order & ~(prov_attr->msg_order)) { FI_INFO(prov, FI_LOG_CORE, "msg_order not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, msg_order, FI_TYPE_MSG_ORDER); return -FI_ENODATA; } if (user_attr->comp_order & ~(prov_attr->comp_order)) { FI_INFO(prov, FI_LOG_CORE, "comp_order not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, comp_order, FI_TYPE_MSG_ORDER); return -FI_ENODATA; } if (user_attr->total_buffered_recv > prov_attr->total_buffered_recv) { FI_INFO(prov, FI_LOG_CORE, "total_buffered_recv too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, total_buffered_recv); return -FI_ENODATA; } if (user_attr->size > prov_attr->size) { FI_INFO(prov, FI_LOG_CORE, "size is greater than supported\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, size); return -FI_ENODATA; } if (user_attr->iov_limit > prov_attr->iov_limit) { FI_INFO(prov, FI_LOG_CORE, "iov_limit too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, iov_limit); return -FI_ENODATA; } if (!rm_enabled && user_attr->total_buffered_recv > prov_attr->total_buffered_recv) { /* Just log a notification, but ignore the value */ FI_INFO(prov, FI_LOG_CORE, "Total buffered recv size exceeds supported size\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, total_buffered_recv); } return 0; }
int ofi_check_ep_attr(const struct util_prov *util_prov, uint32_t api_version, const struct fi_info *prov_info, const struct fi_info *user_info) { const struct fi_ep_attr *prov_attr = prov_info->ep_attr; const struct fi_ep_attr *user_attr = user_info->ep_attr; const struct fi_provider *prov = util_prov->prov; int ret; ret = ofi_check_ep_type(prov, prov_attr, user_attr); if (ret) return ret; if ((user_attr->protocol != FI_PROTO_UNSPEC) && (user_attr->protocol != prov_attr->protocol)) { FI_INFO(prov, FI_LOG_CORE, "Unsupported protocol\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, protocol, FI_TYPE_PROTOCOL); return -FI_ENODATA; } if (user_attr->protocol_version && (user_attr->protocol_version > prov_attr->protocol_version)) { FI_INFO(prov, FI_LOG_CORE, "Unsupported protocol version\n"); return -FI_ENODATA; } if (user_attr->max_msg_size > prov_attr->max_msg_size) { FI_INFO(prov, FI_LOG_CORE, "Max message size too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_msg_size); return -FI_ENODATA; } if (user_attr->tx_ctx_cnt > prov_info->domain_attr->max_ep_tx_ctx) { if (user_attr->tx_ctx_cnt == FI_SHARED_CONTEXT) { if (!prov_info->domain_attr->max_ep_stx_ctx) { FI_INFO(prov, FI_LOG_CORE, "Shared tx context not supported\n"); return -FI_ENODATA; } } else { FI_INFO(prov, FI_LOG_CORE, "Requested tx_ctx_cnt exceeds supported." " Expected:%zd, Requested%zd\n", prov_info->domain_attr->max_ep_tx_ctx, user_attr->tx_ctx_cnt); return -FI_ENODATA; } } if (user_attr->rx_ctx_cnt > prov_info->domain_attr->max_ep_rx_ctx) { if (user_attr->rx_ctx_cnt == FI_SHARED_CONTEXT) { if (!prov_info->domain_attr->max_ep_srx_ctx) { FI_INFO(prov, FI_LOG_CORE, "Shared rx context not supported\n"); return -FI_ENODATA; } } else { FI_INFO(prov, FI_LOG_CORE, "Requested rx_ctx_cnt exceeds supported." " Expected: %zd, Requested:%zd\n", prov_info->domain_attr->max_ep_rx_ctx, user_attr->rx_ctx_cnt); return -FI_ENODATA; } } if (user_info->caps & (FI_RMA | FI_ATOMIC)) { if (user_attr->max_order_raw_size > prov_attr->max_order_raw_size) { FI_INFO(prov, FI_LOG_CORE, "Max order RAW size exceeds supported size\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_order_raw_size); return -FI_ENODATA; } if (user_attr->max_order_war_size > prov_attr->max_order_war_size) { FI_INFO(prov, FI_LOG_CORE, "Max order WAR size exceeds supported size\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_order_war_size); return -FI_ENODATA; } if (user_attr->max_order_waw_size > prov_attr->max_order_waw_size) { FI_INFO(prov, FI_LOG_CORE, "Max order WAW size exceeds supported size\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_order_waw_size); return -FI_ENODATA; } } if (user_attr->auth_key_size && (user_attr->auth_key_size != prov_attr->auth_key_size)) { FI_INFO(prov, FI_LOG_CORE, "Unsupported authentication size."); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, auth_key_size); return -FI_ENODATA; } return 0; }
int ofi_check_domain_attr(const struct fi_provider *prov, uint32_t api_version, const struct fi_domain_attr *prov_attr, const struct fi_info *user_info) { const struct fi_domain_attr *user_attr = user_info->domain_attr; if (prov_attr->name && user_attr->name && strcasecmp(user_attr->name, prov_attr->name)) { FI_INFO(prov, FI_LOG_CORE, "Unknown domain name\n"); FI_INFO_NAME(prov, prov_attr, user_attr); return -FI_ENODATA; } if (fi_thread_level(user_attr->threading) < fi_thread_level(prov_attr->threading)) { FI_INFO(prov, FI_LOG_CORE, "Invalid threading model\n"); return -FI_ENODATA; } if (fi_progress_level(user_attr->control_progress) < fi_progress_level(prov_attr->control_progress)) { FI_INFO(prov, FI_LOG_CORE, "Invalid control progress model\n"); return -FI_ENODATA; } if (fi_progress_level(user_attr->data_progress) < fi_progress_level(prov_attr->data_progress)) { FI_INFO(prov, FI_LOG_CORE, "Invalid data progress model\n"); return -FI_ENODATA; } if (fi_resource_mgmt_level(user_attr->resource_mgmt) < fi_resource_mgmt_level(prov_attr->resource_mgmt)) { FI_INFO(prov, FI_LOG_CORE, "Invalid resource mgmt model\n"); return -FI_ENODATA; } if ((prov_attr->av_type != FI_AV_UNSPEC) && (user_attr->av_type != FI_AV_UNSPEC) && (prov_attr->av_type != user_attr->av_type)) { FI_INFO(prov, FI_LOG_CORE, "Invalid AV type\n"); return -FI_ENODATA; } if (user_attr->cq_data_size > prov_attr->cq_data_size) { FI_INFO(prov, FI_LOG_CORE, "CQ data size too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, cq_data_size); return -FI_ENODATA; } if (ofi_check_mr_mode(prov, api_version, prov_attr->mr_mode, user_info)) return -FI_ENODATA; if (user_attr->max_ep_stx_ctx > prov_attr->max_ep_stx_ctx) { FI_INFO(prov, FI_LOG_CORE, "max_ep_stx_ctx greater than supported\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_ep_stx_ctx); } if (user_attr->max_ep_srx_ctx > prov_attr->max_ep_srx_ctx) { FI_INFO(prov, FI_LOG_CORE, "max_ep_srx_ctx greater than supported\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_ep_srx_ctx); } /* following checks only apply to api 1.5 and beyond */ if (FI_VERSION_LT(api_version, FI_VERSION(1, 5))) return 0; if (user_attr->cntr_cnt > prov_attr->cntr_cnt) { FI_INFO(prov, FI_LOG_CORE, "Cntr count too large\n"); return -FI_ENODATA; } if (user_attr->mr_iov_limit > prov_attr->mr_iov_limit) { FI_INFO(prov, FI_LOG_CORE, "MR iov limit too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, mr_iov_limit); return -FI_ENODATA; } if (user_attr->caps & ~(prov_attr->caps)) { FI_INFO(prov, FI_LOG_CORE, "Requested domain caps not supported\n"); FI_INFO_CHECK(prov, prov_attr, user_attr, caps, FI_TYPE_CAPS); return -FI_ENODATA; } if ((user_attr->mode & prov_attr->mode) != prov_attr->mode) { FI_INFO(prov, FI_LOG_CORE, "Required domain mode missing\n"); FI_INFO_MODE(prov, prov_attr->mode, user_attr->mode); return -FI_ENODATA; } if (user_attr->max_err_data > prov_attr->max_err_data) { FI_INFO(prov, FI_LOG_CORE, "Max err data too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, max_err_data); return -FI_ENODATA; } if (user_attr->mr_cnt > prov_attr->mr_cnt) { FI_INFO(prov, FI_LOG_CORE, "MR count too large\n"); FI_INFO_CHECK_VAL(prov, prov_attr, user_attr, mr_cnt); return -FI_ENODATA; } return 0; }
int fi_ibv_check_rx_attr(const struct fi_rx_attr *attr, const struct fi_info *hints, const struct fi_info *info) { uint64_t compare_mode, check_mode; int rm_enabled; if (attr->caps & ~(info->rx_attr->caps)) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->caps not supported\n"); return -FI_ENODATA; } compare_mode = attr->mode ? attr->mode : hints->mode; check_mode = (hints->caps & FI_RMA) ? info->rx_attr->mode : (info->rx_attr->mode & ~FI_RX_CQ_DATA); if ((compare_mode & check_mode) != check_mode) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->mode not supported\n"); FI_INFO_MODE(&fi_ibv_prov, check_mode, compare_mode); return -FI_ENODATA; } if (attr->op_flags & ~(info->rx_attr->op_flags)) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->op_flags not supported\n"); return -FI_ENODATA; } if (attr->msg_order & ~(info->rx_attr->msg_order)) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->msg_order not supported\n"); return -FI_ENODATA; } if (attr->size > info->rx_attr->size) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->size is greater than supported\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->rx_attr, attr, size); return -FI_ENODATA; } rm_enabled =(info->domain_attr && info->domain_attr->resource_mgmt == FI_RM_ENABLED); if (!rm_enabled && (attr->total_buffered_recv > info->rx_attr->total_buffered_recv)) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->total_buffered_recv " "exceeds supported size\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->rx_attr, attr, total_buffered_recv); return -FI_ENODATA; } if (attr->iov_limit > info->rx_attr->iov_limit) { VERBS_INFO(FI_LOG_CORE, "Given rx_attr->iov_limit greater than supported\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->rx_attr, attr, iov_limit); return -FI_ENODATA; } return 0; }
int fi_ibv_check_ep_attr(const struct fi_ep_attr *attr, const struct fi_info *info) { if ((attr->type != FI_EP_UNSPEC) && (attr->type != info->ep_attr->type)) { VERBS_INFO(FI_LOG_CORE, "Unsupported endpoint type\n"); return -FI_ENODATA; } switch (attr->protocol) { case FI_PROTO_UNSPEC: case FI_PROTO_RDMA_CM_IB_RC: case FI_PROTO_IWARP: case FI_PROTO_IB_UD: case FI_PROTO_IB_RDM: case FI_PROTO_IWARP_RDM: break; default: VERBS_INFO(FI_LOG_CORE, "Unsupported protocol\n"); return -FI_ENODATA; } if (attr->protocol_version > 1) { VERBS_INFO(FI_LOG_CORE, "Unsupported protocol version\n"); return -FI_ENODATA; } if (attr->max_msg_size > info->ep_attr->max_msg_size) { VERBS_INFO(FI_LOG_CORE, "Max message size too large\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->ep_attr, attr, max_msg_size); return -FI_ENODATA; } if (attr->max_order_raw_size > info->ep_attr->max_order_raw_size) { VERBS_INFO( FI_LOG_CORE, "max_order_raw_size exceeds supported size\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->ep_attr, attr, max_order_raw_size); return -FI_ENODATA; } if (attr->max_order_war_size) { VERBS_INFO(FI_LOG_CORE, "max_order_war_size exceeds supported size\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->ep_attr, attr, max_order_war_size); return -FI_ENODATA; } if (attr->max_order_waw_size > info->ep_attr->max_order_waw_size) { VERBS_INFO(FI_LOG_CORE, "max_order_waw_size exceeds supported size\n"); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->ep_attr, attr, max_order_waw_size); return -FI_ENODATA; } if (attr->tx_ctx_cnt > info->domain_attr->max_ep_tx_ctx) { VERBS_INFO(FI_LOG_CORE, "tx_ctx_cnt exceeds supported size\n"); VERBS_INFO(FI_LOG_CORE, "Supported: %zd\nRequested: %zd\n", info->domain_attr->max_ep_tx_ctx, attr->tx_ctx_cnt); return -FI_ENODATA; } if ((attr->rx_ctx_cnt > info->domain_attr->max_ep_rx_ctx) && (attr->rx_ctx_cnt != FI_SHARED_CONTEXT)) { VERBS_INFO(FI_LOG_CORE, "rx_ctx_cnt exceeds supported size\n"); VERBS_INFO(FI_LOG_CORE, "Supported: %zd\nRequested: %zd\n", info->domain_attr->max_ep_rx_ctx, attr->rx_ctx_cnt); return -FI_ENODATA; } if (attr->auth_key_size && (attr->auth_key_size != info->ep_attr->auth_key_size)) { VERBS_INFO(FI_LOG_CORE, "Unsupported authentification size."); FI_INFO_CHECK_VAL(&fi_ibv_prov, info->ep_attr, attr, auth_key_size); return -FI_ENODATA; } return 0; }