/*
 * Copyright (c) 2017 Mellanox Technologies, Inc.  All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     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.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include <infiniband/driver.h>
#include "ibverbs.h"
#include <errno.h>
 
static int advise_mr(struct ibv_pd *pd,
		     enum ibv_advise_mr_advice advice,
		     uint32_t flags,
		     struct ibv_sge *sg_list,
		     uint32_t num_sges)
{
	return EOPNOTSUPP;
}
 
static struct ibv_dm *alloc_dm(struct ibv_context *context,
			       struct ibv_alloc_dm_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_mw *alloc_mw(struct ibv_pd *pd, enum ibv_mw_type type)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_mr *alloc_null_mr(struct ibv_pd *pd)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_pd *
alloc_parent_domain(struct ibv_context *context,
		    struct ibv_parent_domain_init_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_pd *alloc_pd(struct ibv_context *context)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_td *alloc_td(struct ibv_context *context,
			       struct ibv_td_init_attr *init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static void async_event(struct ibv_context *context,
			struct ibv_async_event *event)
{
}
 
static int attach_counters_point_flow(struct ibv_counters *counters,
				      struct ibv_counter_attach_attr *attr,
				      struct ibv_flow *flow)
{
	return EOPNOTSUPP;
}
 
static int attach_mcast(struct ibv_qp *qp, const union ibv_gid *gid,
			uint16_t lid)
{
	return EOPNOTSUPP;
}
 
static int bind_mw(struct ibv_qp *qp, struct ibv_mw *mw,
		   struct ibv_mw_bind *mw_bind)
{
	return EOPNOTSUPP;
}
 
static int close_xrcd(struct ibv_xrcd *xrcd)
{
	return EOPNOTSUPP;
}
 
static void cq_event(struct ibv_cq *cq)
{
}
 
static struct ibv_ah *create_ah(struct ibv_pd *pd, struct ibv_ah_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_counters *create_counters(struct ibv_context *context,
					    struct ibv_counters_init_attr *init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_cq *create_cq(struct ibv_context *context, int cqe,
				struct ibv_comp_channel *channel,
				int comp_vector)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_cq_ex *create_cq_ex(struct ibv_context *context,
				      struct ibv_cq_init_attr_ex *init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_flow *create_flow(struct ibv_qp *qp,
				    struct ibv_flow_attr *flow_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_flow_action *create_flow_action_esp(struct ibv_context *context,
						      struct ibv_flow_action_esp_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_qp *create_qp(struct ibv_pd *pd,
				struct ibv_qp_init_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_qp *create_qp_ex(struct ibv_context *context,
				   struct ibv_qp_init_attr_ex *qp_init_attr_ex)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_rwq_ind_table *
create_rwq_ind_table(struct ibv_context *context,
		     struct ibv_rwq_ind_table_init_attr *init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_srq *create_srq(struct ibv_pd *pd,
				  struct ibv_srq_init_attr *srq_init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_srq *
create_srq_ex(struct ibv_context *context,
	      struct ibv_srq_init_attr_ex *srq_init_attr_ex)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_wq *create_wq(struct ibv_context *context,
				struct ibv_wq_init_attr *wq_init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static int dealloc_mw(struct ibv_mw *mw)
{
	return EOPNOTSUPP;
}
 
static int dealloc_pd(struct ibv_pd *pd)
{
	return EOPNOTSUPP;
}
 
static int dealloc_td(struct ibv_td *td)
{
	return EOPNOTSUPP;
}
 
static int dereg_mr(struct verbs_mr *vmr)
{
	return EOPNOTSUPP;
}
 
static int destroy_ah(struct ibv_ah *ah)
{
	return EOPNOTSUPP;
}
 
static int destroy_counters(struct ibv_counters *counters)
{
	return EOPNOTSUPP;
}
 
static int destroy_cq(struct ibv_cq *cq)
{
	return EOPNOTSUPP;
}
 
static int destroy_flow(struct ibv_flow *flow)
{
	return EOPNOTSUPP;
}
 
static int destroy_flow_action(struct ibv_flow_action *action)
{
	return EOPNOTSUPP;
}
 
static int destroy_qp(struct ibv_qp *qp)
{
	return EOPNOTSUPP;
}
 
static int destroy_rwq_ind_table(struct ibv_rwq_ind_table *rwq_ind_table)
{
	return EOPNOTSUPP;
}
 
static int destroy_srq(struct ibv_srq *srq)
{
	return EOPNOTSUPP;
}
 
static int destroy_wq(struct ibv_wq *wq)
{
	return EOPNOTSUPP;
}
 
static int detach_mcast(struct ibv_qp *qp, const union ibv_gid *gid,
			uint16_t lid)
{
	return EOPNOTSUPP;
}
 
static void free_context(struct ibv_context *ctx)
{
	return;
}
 
static int free_dm(struct ibv_dm *dm)
{
	return EOPNOTSUPP;
}
 
static int get_srq_num(struct ibv_srq *srq, uint32_t *srq_num)
{
	return EOPNOTSUPP;
}
 
static int modify_cq(struct ibv_cq *cq, struct ibv_modify_cq_attr *attr)
{
	return EOPNOTSUPP;
}
 
static int modify_flow_action_esp(struct ibv_flow_action *action,
				  struct ibv_flow_action_esp_attr *attr)
{
	return EOPNOTSUPP;
}
 
static int modify_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, int attr_mask)
{
	return EOPNOTSUPP;
}
 
static int modify_qp_rate_limit(struct ibv_qp *qp,
				struct ibv_qp_rate_limit_attr *attr)
{
	return EOPNOTSUPP;
}
 
static int modify_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr,
		      int srq_attr_mask)
{
	return EOPNOTSUPP;
}
 
static int modify_wq(struct ibv_wq *wq, struct ibv_wq_attr *wq_attr)
{
	return EOPNOTSUPP;
}
 
static struct ibv_qp *open_qp(struct ibv_context *context,
			      struct ibv_qp_open_attr *attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_xrcd *open_xrcd(struct ibv_context *context,
				  struct ibv_xrcd_init_attr *xrcd_init_attr)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static int poll_cq(struct ibv_cq *cq, int num_entries, struct ibv_wc *wc)
{
	return EOPNOTSUPP;
}
 
static int post_recv(struct ibv_qp *qp, struct ibv_recv_wr *wr,
		     struct ibv_recv_wr **bad_wr)
{
	return EOPNOTSUPP;
}
 
static int post_send(struct ibv_qp *qp, struct ibv_send_wr *wr,
		     struct ibv_send_wr **bad_wr)
{
	return EOPNOTSUPP;
}
 
static int post_srq_ops(struct ibv_srq *srq, struct ibv_ops_wr *op,
			struct ibv_ops_wr **bad_op)
{
	return EOPNOTSUPP;
}
 
static int post_srq_recv(struct ibv_srq *srq, struct ibv_recv_wr *recv_wr,
			 struct ibv_recv_wr **bad_recv_wr)
{
	return EOPNOTSUPP;
}
 
static int query_device(struct ibv_context *context,
			struct ibv_device_attr *device_attr)
{
	return EOPNOTSUPP;
}
 
/* Provide a generic implementation for all providers that don't implement
 * query_device_ex.
 */
static int query_device_ex(struct ibv_context *context,
			   const struct ibv_query_device_ex_input *input,
			   struct ibv_device_attr_ex *attr, size_t attr_size)
{
	if (input && input->comp_mask)
		return EINVAL;
 
	if (attr_size < sizeof(attr->orig_attr))
		return EOPNOTSUPP;
 
	memset(&attr->orig_attr, 0, sizeof(attr->orig_attr));
 
	return ibv_query_device(context, &attr->orig_attr);
}
 
static int query_port(struct ibv_context *context, uint8_t port_num,
		      struct ibv_port_attr *port_attr)
{
	return EOPNOTSUPP;
}
 
static int query_qp(struct ibv_qp *qp, struct ibv_qp_attr *attr, int attr_mask,
		    struct ibv_qp_init_attr *init_attr)
{
	return EOPNOTSUPP;
}
 
static int query_rt_values(struct ibv_context *context,
			   struct ibv_values_ex *values)
{
	return EOPNOTSUPP;
}
 
static int query_srq(struct ibv_srq *srq, struct ibv_srq_attr *srq_attr)
{
	return EOPNOTSUPP;
}
 
static int read_counters(struct ibv_counters *counters,
			 uint64_t *counters_value,
			 uint32_t ncounters,
			 uint32_t flags)
{
	return EOPNOTSUPP;
}
 
static struct ibv_mr *reg_dm_mr(struct ibv_pd *pd, struct ibv_dm *dm,
				uint64_t dm_offset, size_t length,
				unsigned int access)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static struct ibv_mr *reg_mr(struct ibv_pd *pd, void *addr, size_t length,
			     uint64_t hca_va,  int access)
{
	errno = EOPNOTSUPP;
	return NULL;
}
 
static int req_notify_cq(struct ibv_cq *cq, int solicited_only)
{
	return EOPNOTSUPP;
}
 
static int rereg_mr(struct verbs_mr *vmr, int flags, struct ibv_pd *pd,
		    void *addr, size_t length, int access)
{
	errno = EOPNOTSUPP;
	return IBV_REREG_MR_ERR_INPUT;
}
 
static int resize_cq(struct ibv_cq *cq, int cqe)
{
	return EOPNOTSUPP;
}
 
/*
 * Ops in verbs_dummy_ops simply return an EOPNOTSUPP error code when called, or
 * do nothing. They are placed in the ops structures if the provider does not
 * provide an op for the function.
 *
 * NOTE: This deliberately does not use named initializers to trigger a
 * '-Wmissing-field-initializers' warning if the struct is changed without
 * changing this.
 *
 * Keep sorted.
 */
const struct verbs_context_ops verbs_dummy_ops = {
	advise_mr,
	alloc_dm,
	alloc_mw,
	alloc_null_mr,
	alloc_parent_domain,
	alloc_pd,
	alloc_td,
	async_event,
	attach_counters_point_flow,
	attach_mcast,
	bind_mw,
	close_xrcd,
	cq_event,
	create_ah,
	create_counters,
	create_cq,
	create_cq_ex,
	create_flow,
	create_flow_action_esp,
	create_qp,
	create_qp_ex,
	create_rwq_ind_table,
	create_srq,
	create_srq_ex,
	create_wq,
	dealloc_mw,
	dealloc_pd,
	dealloc_td,
	dereg_mr,
	destroy_ah,
	destroy_counters,
	destroy_cq,
	destroy_flow,
	destroy_flow_action,
	destroy_qp,
	destroy_rwq_ind_table,
	destroy_srq,
	destroy_wq,
	detach_mcast,
	free_context,
	free_dm,
	get_srq_num,
	modify_cq,
	modify_flow_action_esp,
	modify_qp,
	modify_qp_rate_limit,
	modify_srq,
	modify_wq,
	open_qp,
	open_xrcd,
	poll_cq,
	post_recv,
	post_send,
	post_srq_ops,
	post_srq_recv,
	query_device,
	query_device_ex,
	query_port,
	query_qp,
	query_rt_values,
	query_srq,
	read_counters,
	reg_dm_mr,
	reg_mr,
	req_notify_cq,
	rereg_mr,
	resize_cq,
};
 
/*
 * Set the ops in a context. If the function pointer in op is NULL then it is
 * not set. This allows the providers to call the function multiple times in
 * order to have variations of the ops for different HW configurations.
 */
void verbs_set_ops(struct verbs_context *vctx,
		   const struct verbs_context_ops *ops)
{
	struct verbs_ex_private *priv = vctx->priv;
	struct ibv_context_ops *ctx = &vctx->context.ops;
 
	/*
	 * We retain the function pointer for now, just as 'just-in-case' ABI
	 * compatibility. If any ever get changed incompatibly they should be
	 * set to NULL instead.
	 */
#define SET_PRIV_OP(ptr, name)                                                 \
	do {                                                                   \
		if (ops->name) {                                               \
			priv->ops.name = ops->name;                            \
			(ptr)->_compat_##name = (void *)ops->name;             \
		}                                                              \
	} while (0)
 
	/* Same as SET_PRIV_OP but without the compatibility pointer */
#define SET_PRIV_OP_IC(ptr, name)                                              \
	do {                                                                   \
		if (ops->name)                                                 \
			priv->ops.name = ops->name;                            \
	} while (0)
 
#define SET_OP(ptr, name)                                                      \
	do {                                                                   \
		if (ops->name) {                                               \
			priv->ops.name = ops->name;                            \
			(ptr)->name = ops->name;                               \
		}                                                              \
	} while (0)
 
#define SET_OP2(ptr, iname, name)                                              \
	do {                                                                   \
		if (ops->name) {                                               \
			priv->ops.name = ops->name;                            \
			(ptr)->iname = ops->name;                              \
		}                                                              \
	} while (0)
 
	SET_OP(vctx, advise_mr);
	SET_OP(vctx, alloc_dm);
	SET_OP(ctx, alloc_mw);
	SET_OP(vctx, alloc_null_mr);
	SET_PRIV_OP(ctx, alloc_pd);
	SET_OP(vctx, alloc_parent_domain);
	SET_OP(vctx, alloc_td);
	SET_OP(vctx, attach_counters_point_flow);
	SET_OP(vctx, create_counters);
	SET_PRIV_OP(ctx, async_event);
	SET_PRIV_OP(ctx, attach_mcast);
	SET_OP(ctx, bind_mw);
	SET_OP(vctx, close_xrcd);
	SET_PRIV_OP(ctx, cq_event);
	SET_PRIV_OP(ctx, create_ah);
	SET_PRIV_OP(ctx, create_cq);
	SET_PRIV_OP_IC(vctx, create_cq_ex);
	SET_OP2(vctx, ibv_create_flow, create_flow);
	SET_OP(vctx, create_flow_action_esp);
	SET_PRIV_OP(ctx, create_qp);
	SET_OP(vctx, create_qp_ex);
	SET_OP(vctx, create_rwq_ind_table);
	SET_PRIV_OP(ctx, create_srq);
	SET_OP(vctx, create_srq_ex);
	SET_OP(vctx, create_wq);
	SET_OP(ctx, dealloc_mw);
	SET_PRIV_OP(ctx, dealloc_pd);
	SET_OP(vctx, dealloc_td);
	SET_OP(vctx, destroy_counters);
	SET_PRIV_OP(ctx, dereg_mr);
	SET_PRIV_OP(ctx, destroy_ah);
	SET_PRIV_OP(ctx, destroy_cq);
	SET_OP2(vctx, ibv_destroy_flow, destroy_flow);
	SET_OP(vctx, destroy_flow_action);
	SET_PRIV_OP(ctx, destroy_qp);
	SET_OP(vctx, destroy_rwq_ind_table);
	SET_PRIV_OP(ctx, destroy_srq);
	SET_OP(vctx, destroy_wq);
	SET_PRIV_OP(ctx, detach_mcast);
	SET_PRIV_OP_IC(ctx, free_context);
	SET_OP(vctx, free_dm);
	SET_OP(vctx, get_srq_num);
	SET_OP(vctx, modify_cq);
	SET_OP(vctx, modify_flow_action_esp);
	SET_PRIV_OP(ctx, modify_qp);
	SET_OP(vctx, modify_qp_rate_limit);
	SET_PRIV_OP(ctx, modify_srq);
	SET_OP(vctx, modify_wq);
	SET_OP(vctx, open_qp);
	SET_OP(vctx, open_xrcd);
	SET_OP(ctx, poll_cq);
	SET_OP(ctx, post_recv);
	SET_OP(ctx, post_send);
	SET_OP(vctx, post_srq_ops);
	SET_OP(ctx, post_srq_recv);
	SET_PRIV_OP(ctx, query_device);
	SET_OP(vctx, query_device_ex);
	SET_PRIV_OP_IC(ctx, query_port);
	SET_PRIV_OP(ctx, query_qp);
	SET_OP(vctx, query_rt_values);
	SET_OP(vctx, read_counters);
	SET_PRIV_OP(ctx, query_srq);
	SET_OP(vctx, reg_dm_mr);
	SET_PRIV_OP(ctx, reg_mr);
	SET_OP(ctx, req_notify_cq);
	SET_PRIV_OP(ctx, rereg_mr);
	SET_PRIV_OP(ctx, resize_cq);
 
#undef SET_OP
#undef SET_OP2
}