[linux-2.6-block.git] / drivers / infiniband / core / uverbs_std_types_device.c

// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
/*
 * Copyright (c) 2018, Mellanox Technologies inc.  All rights reserved.
 */

#include <linux/overflow.h>
#include <rdma/uverbs_std_types.h>
#include "rdma_core.h"
#include "uverbs.h"
#include <rdma/uverbs_ioctl.h>
#include <rdma/opa_addr.h>
#include <rdma/ib_cache.h>

/*
 * This ioctl method allows calling any defined write or write_ex
 * handler. This essentially replaces the hdr/ex_hdr system with the ioctl
 * marshalling, and brings the non-ex path into the same marshalling as the ex
 * path.
 */
static int UVERBS_HANDLER(UVERBS_METHOD_INVOKE_WRITE)(
	struct uverbs_attr_bundle *attrs)
{
	struct uverbs_api *uapi = attrs->ufile->device->uapi;
	const struct uverbs_api_write_method *method_elm;
	u32 cmd;
	int rc;

	rc = uverbs_get_const(&cmd, attrs, UVERBS_ATTR_WRITE_CMD);
	if (rc)
		return rc;

	method_elm = uapi_get_method(uapi, cmd);
	if (IS_ERR(method_elm))
		return PTR_ERR(method_elm);

	uverbs_fill_udata(attrs, &attrs->ucore, UVERBS_ATTR_CORE_IN,
			  UVERBS_ATTR_CORE_OUT);

	if (attrs->ucore.inlen < method_elm->req_size ||
	    attrs->ucore.outlen < method_elm->resp_size)
		return -ENOSPC;

	attrs->uobject = NULL;
	rc = method_elm->handler(attrs);
	if (attrs->uobject)
		uverbs_finalize_object(attrs->uobject, UVERBS_ACCESS_NEW, true,
				       !rc, attrs);
	return rc;
}

DECLARE_UVERBS_NAMED_METHOD(UVERBS_METHOD_INVOKE_WRITE,
			    UVERBS_ATTR_CONST_IN(UVERBS_ATTR_WRITE_CMD,
						 enum ib_uverbs_write_cmds,
						 UA_MANDATORY),
			    UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CORE_IN,
					       UVERBS_ATTR_MIN_SIZE(sizeof(u32)),
					       UA_OPTIONAL),
			    UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_CORE_OUT,
						UVERBS_ATTR_MIN_SIZE(0),
						UA_OPTIONAL),
			    UVERBS_ATTR_UHW());

static uint32_t *
gather_objects_handle(struct ib_uverbs_file *ufile,
		      const struct uverbs_api_object *uapi_object,
		      struct uverbs_attr_bundle *attrs,
		      ssize_t out_len,
		      u64 *total)
{
	u64 max_count = out_len / sizeof(u32);
	struct ib_uobject *obj;
	u64 count = 0;
	u32 *handles;

	/* Allocated memory that cannot page out where we gather
	 * all object ids under a spin_lock.
	 */
	handles = uverbs_zalloc(attrs, out_len);
	if (IS_ERR(handles))
		return handles;

	spin_lock_irq(&ufile->uobjects_lock);
	list_for_each_entry(obj, &ufile->uobjects, list) {
		u32 obj_id = obj->id;

		if (obj->uapi_object != uapi_object)
			continue;

		if (count >= max_count)
			break;

		handles[count] = obj_id;
		count++;
	}
	spin_unlock_irq(&ufile->uobjects_lock);

	*total = count;
	return handles;
}

static int UVERBS_HANDLER(UVERBS_METHOD_INFO_HANDLES)(
	struct uverbs_attr_bundle *attrs)
{
	const struct uverbs_api_object *uapi_object;
	ssize_t out_len;
	u64 total = 0;
	u16 object_id;
	u32 *handles;
	int ret;

	out_len = uverbs_attr_get_len(attrs, UVERBS_ATTR_INFO_HANDLES_LIST);
	if (out_len <= 0 || (out_len % sizeof(u32) != 0))
		return -EINVAL;

	ret = uverbs_get_const(&object_id, attrs, UVERBS_ATTR_INFO_OBJECT_ID);
	if (ret)
		return ret;

	uapi_object = uapi_get_object(attrs->ufile->device->uapi, object_id);
	if (!uapi_object)
		return -EINVAL;

	handles = gather_objects_handle(attrs->ufile, uapi_object, attrs,
					out_len, &total);
	if (IS_ERR(handles))
		return PTR_ERR(handles);

	ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_HANDLES_LIST, handles,
			     sizeof(u32) * total);
	if (ret)
		goto err;

	ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_TOTAL_HANDLES, &total,
			     sizeof(total));
err:
	return ret;
}

void copy_port_attr_to_resp(struct ib_port_attr *attr,
			    struct ib_uverbs_query_port_resp *resp,
			    struct ib_device *ib_dev, u8 port_num)
{
	resp->state = attr->state;
	resp->max_mtu = attr->max_mtu;
	resp->active_mtu = attr->active_mtu;
	resp->gid_tbl_len = attr->gid_tbl_len;
	resp->port_cap_flags = make_port_cap_flags(attr);
	resp->max_msg_sz = attr->max_msg_sz;
	resp->bad_pkey_cntr = attr->bad_pkey_cntr;
	resp->qkey_viol_cntr = attr->qkey_viol_cntr;
	resp->pkey_tbl_len = attr->pkey_tbl_len;

	if (rdma_is_grh_required(ib_dev, port_num))
		resp->flags |= IB_UVERBS_QPF_GRH_REQUIRED;

	if (rdma_cap_opa_ah(ib_dev, port_num)) {
		resp->lid = OPA_TO_IB_UCAST_LID(attr->lid);
		resp->sm_lid = OPA_TO_IB_UCAST_LID(attr->sm_lid);
	} else {
		resp->lid = ib_lid_cpu16(attr->lid);
		resp->sm_lid = ib_lid_cpu16(attr->sm_lid);
	}

	resp->lmc = attr->lmc;
	resp->max_vl_num = attr->max_vl_num;
	resp->sm_sl = attr->sm_sl;
	resp->subnet_timeout = attr->subnet_timeout;
	resp->init_type_reply = attr->init_type_reply;
	resp->active_width = attr->active_width;
	/* This ABI needs to be extended to provide any speed more than IB_SPEED_NDR */
	resp->active_speed = min_t(u16, attr->active_speed, IB_SPEED_NDR);
	resp->phys_state = attr->phys_state;
	resp->link_layer = rdma_port_get_link_layer(ib_dev, port_num);
}

static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_PORT)(
	struct uverbs_attr_bundle *attrs)
{
	struct ib_device *ib_dev;
	struct ib_port_attr attr = {};
	struct ib_uverbs_query_port_resp_ex resp = {};
	struct ib_ucontext *ucontext;
	int ret;
	u8 port_num;

	ucontext = ib_uverbs_get_ucontext(attrs);
	if (IS_ERR(ucontext))
		return PTR_ERR(ucontext);
	ib_dev = ucontext->device;

	/* FIXME: Extend the UAPI_DEF_OBJ_NEEDS_FN stuff.. */
	if (!ib_dev->ops.query_port)
		return -EOPNOTSUPP;

	ret = uverbs_get_const(&port_num, attrs,
			       UVERBS_ATTR_QUERY_PORT_PORT_NUM);
	if (ret)
		return ret;

	ret = ib_query_port(ib_dev, port_num, &attr);
	if (ret)
		return ret;

	copy_port_attr_to_resp(&attr, &resp.legacy_resp, ib_dev, port_num);
	resp.port_cap_flags2 = attr.port_cap_flags2;

	return uverbs_copy_to_struct_or_zero(attrs, UVERBS_ATTR_QUERY_PORT_RESP,
					     &resp, sizeof(resp));
}

static int UVERBS_HANDLER(UVERBS_METHOD_GET_CONTEXT)(
	struct uverbs_attr_bundle *attrs)
{
	u32 num_comp = attrs->ufile->device->num_comp_vectors;
	u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
	int ret;

	ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
			     &num_comp, sizeof(num_comp));
	if (IS_UVERBS_COPY_ERR(ret))
		return ret;

	ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
			     &core_support, sizeof(core_support));
	if (IS_UVERBS_COPY_ERR(ret))
		return ret;

	ret = ib_alloc_ucontext(attrs);
	if (ret)
		return ret;
	ret = ib_init_ucontext(attrs);
	if (ret) {
		kfree(attrs->context);
		attrs->context = NULL;
		return ret;
	}
	return 0;
}

static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_CONTEXT)(
	struct uverbs_attr_bundle *attrs)
{
	u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
	struct ib_ucontext *ucontext;
	struct ib_device *ib_dev;
	u32 num_comp;
	int ret;

	ucontext = ib_uverbs_get_ucontext(attrs);
	if (IS_ERR(ucontext))
		return PTR_ERR(ucontext);
	ib_dev = ucontext->device;

	if (!ib_dev->ops.query_ucontext)
		return -EOPNOTSUPP;

	num_comp = attrs->ufile->device->num_comp_vectors;
	ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
			     &num_comp, sizeof(num_comp));
	if (IS_UVERBS_COPY_ERR(ret))
		return ret;

	ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
			     &core_support, sizeof(core_support));
	if (IS_UVERBS_COPY_ERR(ret))
		return ret;

	return ucontext->device->ops.query_ucontext(ucontext, attrs);
}

static int copy_gid_entries_to_user(struct uverbs_attr_bundle *attrs,
				    struct ib_uverbs_gid_entry *entries,
				    size_t num_entries, size_t user_entry_size)
{
	const struct uverbs_attr *attr;
	void __user *user_entries;
	size_t copy_len;
	int ret;
	int i;

	if (user_entry_size == sizeof(*entries)) {
		ret = uverbs_copy_to(attrs,
				     UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
				     entries, sizeof(*entries) * num_entries);
		return ret;
	}

	copy_len = min_t(size_t, user_entry_size, sizeof(*entries));
	attr = uverbs_attr_get(attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
	if (IS_ERR(attr))
		return PTR_ERR(attr);

	user_entries = u64_to_user_ptr(attr->ptr_attr.data);
	for (i = 0; i < num_entries; i++) {
		if (copy_to_user(user_entries, entries, copy_len))
			return -EFAULT;

		if (user_entry_size > sizeof(*entries)) {
			if (clear_user(user_entries + sizeof(*entries),
				       user_entry_size - sizeof(*entries)))
				return -EFAULT;
		}

		entries++;
		user_entries += user_entry_size;
	}

	return uverbs_output_written(attrs,
				     UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
}

static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_TABLE)(
	struct uverbs_attr_bundle *attrs)
{
	struct ib_uverbs_gid_entry *entries;
	struct ib_ucontext *ucontext;
	struct ib_device *ib_dev;
	size_t user_entry_size;
	ssize_t num_entries;
	int max_entries;
	u32 flags;
	int ret;

	ret = uverbs_get_flags32(&flags, attrs,
				 UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, 0);
	if (ret)
		return ret;

	ret = uverbs_get_const(&user_entry_size, attrs,
			       UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE);
	if (ret)
		return ret;

	if (!user_entry_size)
		return -EINVAL;

	max_entries = uverbs_attr_ptr_get_array_size(
		attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
		user_entry_size);
	if (max_entries <= 0)
		return max_entries ?: -EINVAL;

	ucontext = ib_uverbs_get_ucontext(attrs);
	if (IS_ERR(ucontext))
		return PTR_ERR(ucontext);
	ib_dev = ucontext->device;

	entries = uverbs_kcalloc(attrs, max_entries, sizeof(*entries));
	if (IS_ERR(entries))
		return PTR_ERR(entries);

	num_entries = rdma_query_gid_table(ib_dev, entries, max_entries);
	if (num_entries < 0)
		return -EINVAL;

	ret = copy_gid_entries_to_user(attrs, entries, num_entries,
				       user_entry_size);
	if (ret)
		return ret;

	ret = uverbs_copy_to(attrs,
			     UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
			     &num_entries, sizeof(num_entries));
	return ret;
}

static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_ENTRY)(
	struct uverbs_attr_bundle *attrs)
{
	struct ib_uverbs_gid_entry entry = {};
	const struct ib_gid_attr *gid_attr;
	struct ib_ucontext *ucontext;
	struct ib_device *ib_dev;
	struct net_device *ndev;
	u32 gid_index;
	u32 port_num;
	u32 flags;
	int ret;

	ret = uverbs_get_flags32(&flags, attrs,
				 UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, 0);
	if (ret)
		return ret;

	ret = uverbs_get_const(&port_num, attrs,
			       UVERBS_ATTR_QUERY_GID_ENTRY_PORT);
	if (ret)
		return ret;

	ret = uverbs_get_const(&gid_index, attrs,
			       UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX);
	if (ret)
		return ret;

	ucontext = ib_uverbs_get_ucontext(attrs);
	if (IS_ERR(ucontext))
		return PTR_ERR(ucontext);
	ib_dev = ucontext->device;

	if (!rdma_is_port_valid(ib_dev, port_num))
		return -EINVAL;

	gid_attr = rdma_get_gid_attr(ib_dev, port_num, gid_index);
	if (IS_ERR(gid_attr))
		return PTR_ERR(gid_attr);

	memcpy(&entry.gid, &gid_attr->gid, sizeof(gid_attr->gid));
	entry.gid_index = gid_attr->index;
	entry.port_num = gid_attr->port_num;
	entry.gid_type = gid_attr->gid_type;

	rcu_read_lock();
	ndev = rdma_read_gid_attr_ndev_rcu(gid_attr);
	if (IS_ERR(ndev)) {
		if (PTR_ERR(ndev) != -ENODEV) {
			ret = PTR_ERR(ndev);
			rcu_read_unlock();
			goto out;
		}
	} else {
		entry.netdev_ifindex = ndev->ifindex;
	}
	rcu_read_unlock();

	ret = uverbs_copy_to_struct_or_zero(
		attrs, UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY, &entry,
		sizeof(entry));
out:
	rdma_put_gid_attr(gid_attr);
	return ret;
}

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_GET_CONTEXT,
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
			    UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
			    UVERBS_ATTR_TYPE(u64), UA_OPTIONAL),
	UVERBS_ATTR_UHW());

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_QUERY_CONTEXT,
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
			    UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
			    UVERBS_ATTR_TYPE(u64), UA_OPTIONAL));

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_INFO_HANDLES,
	/* Also includes any device specific object ids */
	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_INFO_OBJECT_ID,
			     enum uverbs_default_objects, UA_MANDATORY),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_TOTAL_HANDLES,
			    UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_HANDLES_LIST,
			    UVERBS_ATTR_MIN_SIZE(sizeof(u32)), UA_OPTIONAL));

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_QUERY_PORT,
	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_PORT_PORT_NUM, u8, UA_MANDATORY),
	UVERBS_ATTR_PTR_OUT(
		UVERBS_ATTR_QUERY_PORT_RESP,
		UVERBS_ATTR_STRUCT(struct ib_uverbs_query_port_resp_ex,
				   reserved),
		UA_MANDATORY));

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_QUERY_GID_TABLE,
	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE, u64,
			     UA_MANDATORY),
	UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, u32,
			     UA_OPTIONAL),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
			    UVERBS_ATTR_MIN_SIZE(0), UA_MANDATORY),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
			    UVERBS_ATTR_TYPE(u64), UA_MANDATORY));

DECLARE_UVERBS_NAMED_METHOD(
	UVERBS_METHOD_QUERY_GID_ENTRY,
	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_PORT, u32,
			     UA_MANDATORY),
	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX, u32,
			     UA_MANDATORY),
	UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, u32,
			     UA_MANDATORY),
	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY,
			    UVERBS_ATTR_STRUCT(struct ib_uverbs_gid_entry,
					       netdev_ifindex),
			    UA_MANDATORY));

DECLARE_UVERBS_GLOBAL_METHODS(UVERBS_OBJECT_DEVICE,
			      &UVERBS_METHOD(UVERBS_METHOD_GET_CONTEXT),
			      &UVERBS_METHOD(UVERBS_METHOD_INVOKE_WRITE),
			      &UVERBS_METHOD(UVERBS_METHOD_INFO_HANDLES),
			      &UVERBS_METHOD(UVERBS_METHOD_QUERY_PORT),
			      &UVERBS_METHOD(UVERBS_METHOD_QUERY_CONTEXT),
			      &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_TABLE),
			      &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_ENTRY));

const struct uapi_definition uverbs_def_obj_device[] = {
	UAPI_DEF_CHAIN_OBJ_TREE_NAMED(UVERBS_OBJECT_DEVICE),
	{},
};
Commit	Line	Data
4785860e JG	1	// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
	2	/*
	3	* Copyright (c) 2018, Mellanox Technologies inc. All rights reserved.
	4	*/
	5
9f85cbe5	6	#include <linux/overflow.h>
4785860e JG	7	#include <rdma/uverbs_std_types.h>
	8	#include "rdma_core.h"
	9	#include "uverbs.h"
641d1207 MG	10	#include <rdma/uverbs_ioctl.h>
641d1207 MG	11	#include <rdma/opa_addr.h>
9f85cbe5	12	#include <rdma/ib_cache.h>
4785860e JG	13
	14	/*
	15	* This ioctl method allows calling any defined write or write_ex
	16	* handler. This essentially replaces the hdr/ex_hdr system with the ioctl
	17	* marshalling, and brings the non-ex path into the same marshalling as the ex
	18	* path.
	19	*/
	20	static int UVERBS_HANDLER(UVERBS_METHOD_INVOKE_WRITE)(
	21	struct uverbs_attr_bundle *attrs)
	22	{
	23	struct uverbs_api *uapi = attrs->ufile->device->uapi;
	24	const struct uverbs_api_write_method *method_elm;
	25	u32 cmd;
	26	int rc;
	27
	28	rc = uverbs_get_const(&cmd, attrs, UVERBS_ATTR_WRITE_CMD);
	29	if (rc)
	30	return rc;
	31
	32	method_elm = uapi_get_method(uapi, cmd);
	33	if (IS_ERR(method_elm))
	34	return PTR_ERR(method_elm);
	35
	36	uverbs_fill_udata(attrs, &attrs->ucore, UVERBS_ATTR_CORE_IN,
	37	UVERBS_ATTR_CORE_OUT);
	38
	39	if (attrs->ucore.inlen < method_elm->req_size \|\|
	40	attrs->ucore.outlen < method_elm->resp_size)
	41	return -ENOSPC;
	42
0f63ef1d LR	43	attrs->uobject = NULL;
	44	rc = method_elm->handler(attrs);
	45	if (attrs->uobject)
	46	uverbs_finalize_object(attrs->uobject, UVERBS_ACCESS_NEW, true,
	47	!rc, attrs);
	48	return rc;
4785860e JG	49	}
	50
	51	DECLARE_UVERBS_NAMED_METHOD(UVERBS_METHOD_INVOKE_WRITE,
	52	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_WRITE_CMD,
	53	enum ib_uverbs_write_cmds,
	54	UA_MANDATORY),
	55	UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CORE_IN,
	56	UVERBS_ATTR_MIN_SIZE(sizeof(u32)),
	57	UA_OPTIONAL),
	58	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_CORE_OUT,
	59	UVERBS_ATTR_MIN_SIZE(0),
	60	UA_OPTIONAL),
	61	UVERBS_ATTR_UHW());
	62
149d3845 JG	63	static uint32_t *
	64	gather_objects_handle(struct ib_uverbs_file *ufile,
	65	const struct uverbs_api_object *uapi_object,
	66	struct uverbs_attr_bundle *attrs,
	67	ssize_t out_len,
	68	u64 *total)
	69	{
	70	u64 max_count = out_len / sizeof(u32);
	71	struct ib_uobject *obj;
	72	u64 count = 0;
	73	u32 *handles;
	74
	75	/* Allocated memory that cannot page out where we gather
	76	* all object ids under a spin_lock.
	77	*/
	78	handles = uverbs_zalloc(attrs, out_len);
	79	if (IS_ERR(handles))
	80	return handles;
	81
	82	spin_lock_irq(&ufile->uobjects_lock);
	83	list_for_each_entry(obj, &ufile->uobjects, list) {
	84	u32 obj_id = obj->id;
	85
	86	if (obj->uapi_object != uapi_object)
	87	continue;
	88
	89	if (count >= max_count)
	90	break;
	91
	92	handles[count] = obj_id;
	93	count++;
	94	}
	95	spin_unlock_irq(&ufile->uobjects_lock);
	96
	97	*total = count;
	98	return handles;
	99	}
	100
	101	static int UVERBS_HANDLER(UVERBS_METHOD_INFO_HANDLES)(
	102	struct uverbs_attr_bundle *attrs)
	103	{
	104	const struct uverbs_api_object *uapi_object;
	105	ssize_t out_len;
	106	u64 total = 0;
	107	u16 object_id;
	108	u32 *handles;
	109	int ret;
	110
	111	out_len = uverbs_attr_get_len(attrs, UVERBS_ATTR_INFO_HANDLES_LIST);
	112	if (out_len <= 0 \|\| (out_len % sizeof(u32) != 0))
	113	return -EINVAL;
	114
	115	ret = uverbs_get_const(&object_id, attrs, UVERBS_ATTR_INFO_OBJECT_ID);
	116	if (ret)
	117	return ret;
	118
	119	uapi_object = uapi_get_object(attrs->ufile->device->uapi, object_id);
	120	if (!uapi_object)
	121	return -EINVAL;
	122
	123	handles = gather_objects_handle(attrs->ufile, uapi_object, attrs,
	124	out_len, &total);
	125	if (IS_ERR(handles))
	126	return PTR_ERR(handles);
127
128	ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_HANDLES_LIST, handles,
129	sizeof(u32) * total);
130	if (ret)
131	goto err;
132
133	ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_TOTAL_HANDLES, &total,
134	sizeof(total));
135	err:
136	return ret;
137	}
138
641d1207 MG	139	void copy_port_attr_to_resp(struct ib_port_attr *attr,
	140	struct ib_uverbs_query_port_resp *resp,
	141	struct ib_device *ib_dev, u8 port_num)
	142	{
	143	resp->state = attr->state;
	144	resp->max_mtu = attr->max_mtu;
	145	resp->active_mtu = attr->active_mtu;
	146	resp->gid_tbl_len = attr->gid_tbl_len;
	147	resp->port_cap_flags = make_port_cap_flags(attr);
	148	resp->max_msg_sz = attr->max_msg_sz;
	149	resp->bad_pkey_cntr = attr->bad_pkey_cntr;
	150	resp->qkey_viol_cntr = attr->qkey_viol_cntr;
	151	resp->pkey_tbl_len = attr->pkey_tbl_len;
	152
	153	if (rdma_is_grh_required(ib_dev, port_num))
	154	resp->flags \|= IB_UVERBS_QPF_GRH_REQUIRED;
	155
	156	if (rdma_cap_opa_ah(ib_dev, port_num)) {
	157	resp->lid = OPA_TO_IB_UCAST_LID(attr->lid);
	158	resp->sm_lid = OPA_TO_IB_UCAST_LID(attr->sm_lid);
	159	} else {
	160	resp->lid = ib_lid_cpu16(attr->lid);
	161	resp->sm_lid = ib_lid_cpu16(attr->sm_lid);
	162	}
	163
	164	resp->lmc = attr->lmc;
	165	resp->max_vl_num = attr->max_vl_num;
	166	resp->sm_sl = attr->sm_sl;
	167	resp->subnet_timeout = attr->subnet_timeout;
	168	resp->init_type_reply = attr->init_type_reply;
	169	resp->active_width = attr->active_width;
376ceb31 AL	170	/* This ABI needs to be extended to provide any speed more than IB_SPEED_NDR */
376ceb31 AL	171	resp->active_speed = min_t(u16, attr->active_speed, IB_SPEED_NDR);
641d1207 MG	172	resp->phys_state = attr->phys_state;
	173	resp->link_layer = rdma_port_get_link_layer(ib_dev, port_num);
	174	}
	175
	176	static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_PORT)(
	177	struct uverbs_attr_bundle *attrs)
	178	{
f8ade8e2	179	struct ib_device *ib_dev;
641d1207 MG	180	struct ib_port_attr attr = {};
641d1207 MG	181	struct ib_uverbs_query_port_resp_ex resp = {};
f8ade8e2	182	struct ib_ucontext *ucontext;
641d1207 MG	183	int ret;
	184	u8 port_num;
	185
f8ade8e2 YH	186	ucontext = ib_uverbs_get_ucontext(attrs);
	187	if (IS_ERR(ucontext))
	188	return PTR_ERR(ucontext);
	189	ib_dev = ucontext->device;
	190
641d1207 MG	191	/* FIXME: Extend the UAPI_DEF_OBJ_NEEDS_FN stuff.. */
	192	if (!ib_dev->ops.query_port)
	193	return -EOPNOTSUPP;
	194
	195	ret = uverbs_get_const(&port_num, attrs,
	196	UVERBS_ATTR_QUERY_PORT_PORT_NUM);
	197	if (ret)
	198	return ret;
	199
	200	ret = ib_query_port(ib_dev, port_num, &attr);
	201	if (ret)
	202	return ret;
	203
	204	copy_port_attr_to_resp(&attr, &resp.legacy_resp, ib_dev, port_num);
	205	resp.port_cap_flags2 = attr.port_cap_flags2;
	206
	207	return uverbs_copy_to_struct_or_zero(attrs, UVERBS_ATTR_QUERY_PORT_RESP,
	208	&resp, sizeof(resp));
	209	}
	210
a1123418 JG	211	static int UVERBS_HANDLER(UVERBS_METHOD_GET_CONTEXT)(
	212	struct uverbs_attr_bundle *attrs)
	213	{
	214	u32 num_comp = attrs->ufile->device->num_comp_vectors;
81164699	215	u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
a1123418 JG	216	int ret;
	217
	218	ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
	219	&num_comp, sizeof(num_comp));
	220	if (IS_UVERBS_COPY_ERR(ret))
	221	return ret;
	222
81164699 MG	223	ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
	224	&core_support, sizeof(core_support));
	225	if (IS_UVERBS_COPY_ERR(ret))
	226	return ret;
	227
a1123418 JG	228	ret = ib_alloc_ucontext(attrs);
	229	if (ret)
	230	return ret;
	231	ret = ib_init_ucontext(attrs);
	232	if (ret) {
	233	kfree(attrs->context);
	234	attrs->context = NULL;
	235	return ret;
	236	}
	237	return 0;
	238	}
	239
1c8fb1ea YH	240	static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_CONTEXT)(
	241	struct uverbs_attr_bundle *attrs)
	242	{
	243	u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
	244	struct ib_ucontext *ucontext;
	245	struct ib_device *ib_dev;
	246	u32 num_comp;
	247	int ret;
	248
	249	ucontext = ib_uverbs_get_ucontext(attrs);
	250	if (IS_ERR(ucontext))
	251	return PTR_ERR(ucontext);
	252	ib_dev = ucontext->device;
	253
	254	if (!ib_dev->ops.query_ucontext)
	255	return -EOPNOTSUPP;
	256
	257	num_comp = attrs->ufile->device->num_comp_vectors;
	258	ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
	259	&num_comp, sizeof(num_comp));
	260	if (IS_UVERBS_COPY_ERR(ret))
	261	return ret;
	262
	263	ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
	264	&core_support, sizeof(core_support));
	265	if (IS_UVERBS_COPY_ERR(ret))
	266	return ret;
	267
	268	return ucontext->device->ops.query_ucontext(ucontext, attrs);
	269	}
	270
9f85cbe5 AH	271	static int copy_gid_entries_to_user(struct uverbs_attr_bundle *attrs,
	272	struct ib_uverbs_gid_entry *entries,
	273	size_t num_entries, size_t user_entry_size)
	274	{
	275	const struct uverbs_attr *attr;
	276	void __user *user_entries;
	277	size_t copy_len;
	278	int ret;
	279	int i;
	280
	281	if (user_entry_size == sizeof(*entries)) {
	282	ret = uverbs_copy_to(attrs,
	283	UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
	284	entries, sizeof(entries) num_entries);
	285	return ret;
	286	}
	287
	288	copy_len = min_t(size_t, user_entry_size, sizeof(*entries));
	289	attr = uverbs_attr_get(attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
	290	if (IS_ERR(attr))
	291	return PTR_ERR(attr);
	292
	293	user_entries = u64_to_user_ptr(attr->ptr_attr.data);
	294	for (i = 0; i < num_entries; i++) {
	295	if (copy_to_user(user_entries, entries, copy_len))
	296	return -EFAULT;
	297
	298	if (user_entry_size > sizeof(*entries)) {
	299	if (clear_user(user_entries + sizeof(*entries),
	300	user_entry_size - sizeof(*entries)))
	301	return -EFAULT;
	302	}
	303
	304	entries++;
	305	user_entries += user_entry_size;
	306	}
	307
	308	return uverbs_output_written(attrs,
	309	UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
	310	}
	311
	312	static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_TABLE)(
	313	struct uverbs_attr_bundle *attrs)
	314	{
	315	struct ib_uverbs_gid_entry *entries;
	316	struct ib_ucontext *ucontext;
	317	struct ib_device *ib_dev;
	318	size_t user_entry_size;
	319	ssize_t num_entries;
e0da6899	320	int max_entries;
9f85cbe5 AH	321	u32 flags;
	322	int ret;
	323
	324	ret = uverbs_get_flags32(&flags, attrs,
	325	UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, 0);
	326	if (ret)
	327	return ret;
	328
	329	ret = uverbs_get_const(&user_entry_size, attrs,
	330	UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE);
	331	if (ret)
	332	return ret;
	333
54d87913 LR	334	if (!user_entry_size)
	335	return -EINVAL;
	336
9f85cbe5 AH	337	max_entries = uverbs_attr_ptr_get_array_size(
	338	attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
	339	user_entry_size);
	340	if (max_entries <= 0)
e0da6899	341	return max_entries ?: -EINVAL;
9f85cbe5 AH	342
	343	ucontext = ib_uverbs_get_ucontext(attrs);
	344	if (IS_ERR(ucontext))
	345	return PTR_ERR(ucontext);
	346	ib_dev = ucontext->device;
	347
e0da6899 AH	348	entries = uverbs_kcalloc(attrs, max_entries, sizeof(*entries));
	349	if (IS_ERR(entries))
	350	return PTR_ERR(entries);
9f85cbe5 AH	351
	352	num_entries = rdma_query_gid_table(ib_dev, entries, max_entries);
	353	if (num_entries < 0)
	354	return -EINVAL;
	355
	356	ret = copy_gid_entries_to_user(attrs, entries, num_entries,
	357	user_entry_size);
	358	if (ret)
	359	return ret;
	360
	361	ret = uverbs_copy_to(attrs,
	362	UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
	363	&num_entries, sizeof(num_entries));
	364	return ret;
	365	}
	366
	367	static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_ENTRY)(
	368	struct uverbs_attr_bundle *attrs)
	369	{
	370	struct ib_uverbs_gid_entry entry = {};
	371	const struct ib_gid_attr *gid_attr;
	372	struct ib_ucontext *ucontext;
	373	struct ib_device *ib_dev;
	374	struct net_device *ndev;
	375	u32 gid_index;
	376	u32 port_num;
	377	u32 flags;
	378	int ret;
	379
	380	ret = uverbs_get_flags32(&flags, attrs,
	381	UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, 0);
	382	if (ret)
	383	return ret;
	384
	385	ret = uverbs_get_const(&port_num, attrs,
	386	UVERBS_ATTR_QUERY_GID_ENTRY_PORT);
	387	if (ret)
	388	return ret;
	389
	390	ret = uverbs_get_const(&gid_index, attrs,
	391	UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX);
	392	if (ret)
	393	return ret;
	394
	395	ucontext = ib_uverbs_get_ucontext(attrs);
	396	if (IS_ERR(ucontext))
	397	return PTR_ERR(ucontext);
	398	ib_dev = ucontext->device;
	399
	400	if (!rdma_is_port_valid(ib_dev, port_num))
	401	return -EINVAL;
	402
9f85cbe5 AH	403	gid_attr = rdma_get_gid_attr(ib_dev, port_num, gid_index);
	404	if (IS_ERR(gid_attr))
	405	return PTR_ERR(gid_attr);
	406
	407	memcpy(&entry.gid, &gid_attr->gid, sizeof(gid_attr->gid));
	408	entry.gid_index = gid_attr->index;
	409	entry.port_num = gid_attr->port_num;
	410	entry.gid_type = gid_attr->gid_type;
	411
	412	rcu_read_lock();
	413	ndev = rdma_read_gid_attr_ndev_rcu(gid_attr);
	414	if (IS_ERR(ndev)) {
	415	if (PTR_ERR(ndev) != -ENODEV) {
	416	ret = PTR_ERR(ndev);
	417	rcu_read_unlock();
	418	goto out;
	419	}
	420	} else {
	421	entry.netdev_ifindex = ndev->ifindex;
	422	}
	423	rcu_read_unlock();
	424
	425	ret = uverbs_copy_to_struct_or_zero(
	426	attrs, UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY, &entry,
	427	sizeof(entry));
	428	out:
	429	rdma_put_gid_attr(gid_attr);
	430	return ret;
	431	}
	432
a1123418 JG	433	DECLARE_UVERBS_NAMED_METHOD(
	434	UVERBS_METHOD_GET_CONTEXT,
	435	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
	436	UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
81164699 MG	437	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
81164699 MG	438	UVERBS_ATTR_TYPE(u64), UA_OPTIONAL),
a1123418 JG	439	UVERBS_ATTR_UHW());
a1123418 JG	440
1c8fb1ea YH	441	DECLARE_UVERBS_NAMED_METHOD(
	442	UVERBS_METHOD_QUERY_CONTEXT,
	443	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
	444	UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
	445	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
	446	UVERBS_ATTR_TYPE(u64), UA_OPTIONAL));
	447
149d3845 JG	448	DECLARE_UVERBS_NAMED_METHOD(
	449	UVERBS_METHOD_INFO_HANDLES,
	450	/* Also includes any device specific object ids */
	451	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_INFO_OBJECT_ID,
	452	enum uverbs_default_objects, UA_MANDATORY),
	453	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_TOTAL_HANDLES,
	454	UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
	455	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_HANDLES_LIST,
	456	UVERBS_ATTR_MIN_SIZE(sizeof(u32)), UA_OPTIONAL));
	457
641d1207 MG	458	DECLARE_UVERBS_NAMED_METHOD(
	459	UVERBS_METHOD_QUERY_PORT,
	460	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_PORT_PORT_NUM, u8, UA_MANDATORY),
	461	UVERBS_ATTR_PTR_OUT(
	462	UVERBS_ATTR_QUERY_PORT_RESP,
	463	UVERBS_ATTR_STRUCT(struct ib_uverbs_query_port_resp_ex,
	464	reserved),
	465	UA_MANDATORY));
	466
9f85cbe5 AH	467	DECLARE_UVERBS_NAMED_METHOD(
	468	UVERBS_METHOD_QUERY_GID_TABLE,
	469	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE, u64,
	470	UA_MANDATORY),
	471	UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, u32,
	472	UA_OPTIONAL),
	473	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
	474	UVERBS_ATTR_MIN_SIZE(0), UA_MANDATORY),
	475	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
	476	UVERBS_ATTR_TYPE(u64), UA_MANDATORY));
	477
	478	DECLARE_UVERBS_NAMED_METHOD(
	479	UVERBS_METHOD_QUERY_GID_ENTRY,
	480	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_PORT, u32,
	481	UA_MANDATORY),
	482	UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX, u32,
	483	UA_MANDATORY),
	484	UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, u32,
	485	UA_MANDATORY),
	486	UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY,
	487	UVERBS_ATTR_STRUCT(struct ib_uverbs_gid_entry,
	488	netdev_ifindex),
	489	UA_MANDATORY));
	490
4785860e	491	DECLARE_UVERBS_GLOBAL_METHODS(UVERBS_OBJECT_DEVICE,
a1123418	492	&UVERBS_METHOD(UVERBS_METHOD_GET_CONTEXT),
149d3845	493	&UVERBS_METHOD(UVERBS_METHOD_INVOKE_WRITE),
641d1207	494	&UVERBS_METHOD(UVERBS_METHOD_INFO_HANDLES),
1c8fb1ea	495	&UVERBS_METHOD(UVERBS_METHOD_QUERY_PORT),
9f85cbe5 AH	496	&UVERBS_METHOD(UVERBS_METHOD_QUERY_CONTEXT),
	497	&UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_TABLE),
	498	&UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_ENTRY));
4785860e JG	499
	500	const struct uapi_definition uverbs_def_obj_device[] = {
	501	UAPI_DEF_CHAIN_OBJ_TREE_NAMED(UVERBS_OBJECT_DEVICE),
	502	{},
	503	};