Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband (7c049d08) · Commits · 戴 / test

drivers/infiniband/core/cma.c

+17 −27

Original line number	Original line	Diff line number	Diff line
	@@ -1385,8 +1385,9 @@ static int cma_iw_handler(struct iw_cm_id iw_id, struct iw_cm_event iw_event)
	{		{
	struct rdma_id_private *id_priv = iw_id->context;		struct rdma_id_private *id_priv = iw_id->context;
	struct rdma_cm_event event;		struct rdma_cm_event event;
	struct sockaddr_in *sin;
	int ret = 0;		int ret = 0;
			struct sockaddr laddr = (struct sockaddr )&iw_event->local_addr;
			struct sockaddr raddr = (struct sockaddr )&iw_event->remote_addr;

	if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))		if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))
	return 0;		return 0;
	@@ -1397,10 +1398,10 @@ static int cma_iw_handler(struct iw_cm_id iw_id, struct iw_cm_event iw_event)
	event.event = RDMA_CM_EVENT_DISCONNECTED;		event.event = RDMA_CM_EVENT_DISCONNECTED;
	break;		break;
	case IW_CM_EVENT_CONNECT_REPLY:		case IW_CM_EVENT_CONNECT_REPLY:
	sin = (struct sockaddr_in *) cma_src_addr(id_priv);		memcpy(cma_src_addr(id_priv), laddr,
	*sin = iw_event->local_addr;		rdma_addr_size(laddr));
	sin = (struct sockaddr_in *) cma_dst_addr(id_priv);		memcpy(cma_dst_addr(id_priv), raddr,
	*sin = iw_event->remote_addr;		rdma_addr_size(raddr));
	switch (iw_event->status) {		switch (iw_event->status) {
	case 0:		case 0:
	event.event = RDMA_CM_EVENT_ESTABLISHED;		event.event = RDMA_CM_EVENT_ESTABLISHED;
	@@ -1450,11 +1451,12 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
	{		{
	struct rdma_cm_id *new_cm_id;		struct rdma_cm_id *new_cm_id;
	struct rdma_id_private listen_id, conn_id;		struct rdma_id_private listen_id, conn_id;
	struct sockaddr_in *sin;
	struct net_device *dev = NULL;		struct net_device *dev = NULL;
	struct rdma_cm_event event;		struct rdma_cm_event event;
	int ret;		int ret;
	struct ib_device_attr attr;		struct ib_device_attr attr;
			struct sockaddr laddr = (struct sockaddr )&iw_event->local_addr;
			struct sockaddr raddr = (struct sockaddr )&iw_event->remote_addr;

	listen_id = cm_id->context;		listen_id = cm_id->context;
	if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))		if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))
	@@ -1472,14 +1474,7 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
	mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);		mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);
	conn_id->state = RDMA_CM_CONNECT;		conn_id->state = RDMA_CM_CONNECT;

	dev = ip_dev_find(&init_net, iw_event->local_addr.sin_addr.s_addr);		ret = rdma_translate_ip(laddr, &conn_id->id.route.addr.dev_addr);
	if (!dev) {
	ret = -EADDRNOTAVAIL;
	mutex_unlock(&conn_id->handler_mutex);
	rdma_destroy_id(new_cm_id);
	goto out;
	}
	ret = rdma_copy_addr(&conn_id->id.route.addr.dev_addr, dev, NULL);
	if (ret) {		if (ret) {
	mutex_unlock(&conn_id->handler_mutex);		mutex_unlock(&conn_id->handler_mutex);
	rdma_destroy_id(new_cm_id);		rdma_destroy_id(new_cm_id);
	@@ -1497,10 +1492,8 @@ static int iw_conn_req_handler(struct iw_cm_id *cm_id,
	cm_id->context = conn_id;		cm_id->context = conn_id;
	cm_id->cm_handler = cma_iw_handler;		cm_id->cm_handler = cma_iw_handler;

	sin = (struct sockaddr_in *) cma_src_addr(conn_id);		memcpy(cma_src_addr(conn_id), laddr, rdma_addr_size(laddr));
	*sin = iw_event->local_addr;		memcpy(cma_dst_addr(conn_id), raddr, rdma_addr_size(raddr));
	sin = (struct sockaddr_in *) cma_dst_addr(conn_id);
	*sin = iw_event->remote_addr;

	ret = ib_query_device(conn_id->id.device, &attr);		ret = ib_query_device(conn_id->id.device, &attr);
	if (ret) {		if (ret) {
	@@ -1576,7 +1569,6 @@ static int cma_ib_listen(struct rdma_id_private *id_priv)
	static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)		static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)
	{		{
	int ret;		int ret;
	struct sockaddr_in *sin;
	struct iw_cm_id *id;		struct iw_cm_id *id;

	id = iw_create_cm_id(id_priv->id.device,		id = iw_create_cm_id(id_priv->id.device,
	@@ -1587,8 +1579,8 @@ static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)

	id_priv->cm_id.iw = id;		id_priv->cm_id.iw = id;

	sin = (struct sockaddr_in *) cma_src_addr(id_priv);		memcpy(&id_priv->cm_id.iw->local_addr, cma_src_addr(id_priv),
	id_priv->cm_id.iw->local_addr = *sin;		rdma_addr_size(cma_src_addr(id_priv)));

	ret = iw_cm_listen(id_priv->cm_id.iw, backlog);		ret = iw_cm_listen(id_priv->cm_id.iw, backlog);

	@@ -2803,7 +2795,6 @@ static int cma_connect_iw(struct rdma_id_private *id_priv,
	struct rdma_conn_param *conn_param)		struct rdma_conn_param *conn_param)
	{		{
	struct iw_cm_id *cm_id;		struct iw_cm_id *cm_id;
	struct sockaddr_in* sin;
	int ret;		int ret;
	struct iw_cm_conn_param iw_param;		struct iw_cm_conn_param iw_param;

	@@ -2813,11 +2804,10 @@ static int cma_connect_iw(struct rdma_id_private *id_priv,

	id_priv->cm_id.iw = cm_id;		id_priv->cm_id.iw = cm_id;

	sin = (struct sockaddr_in *) cma_src_addr(id_priv);		memcpy(&cm_id->local_addr, cma_src_addr(id_priv),
	cm_id->local_addr = *sin;		rdma_addr_size(cma_src_addr(id_priv)));
			memcpy(&cm_id->remote_addr, cma_dst_addr(id_priv),
	sin = (struct sockaddr_in *) cma_dst_addr(id_priv);		rdma_addr_size(cma_dst_addr(id_priv)));
	cm_id->remote_addr = *sin;

	ret = cma_modify_qp_rtr(id_priv, conn_param);		ret = cma_modify_qp_rtr(id_priv, conn_param);
	if (ret)		if (ret)

drivers/infiniband/core/uverbs.h

+4 −0

Original line number	Original line	Diff line number	Diff line
	@@ -135,6 +135,7 @@ struct ib_usrq_object {
	struct ib_uqp_object {		struct ib_uqp_object {
	struct ib_uevent_object uevent;		struct ib_uevent_object uevent;
	struct list_head mcast_list;		struct list_head mcast_list;
			struct ib_uxrcd_object *uxrcd;
	};		};

	struct ib_ucq_object {		struct ib_ucq_object {
	@@ -155,6 +156,7 @@ extern struct idr ib_uverbs_cq_idr;
	extern struct idr ib_uverbs_qp_idr;		extern struct idr ib_uverbs_qp_idr;
	extern struct idr ib_uverbs_srq_idr;		extern struct idr ib_uverbs_srq_idr;
	extern struct idr ib_uverbs_xrcd_idr;		extern struct idr ib_uverbs_xrcd_idr;
			extern struct idr ib_uverbs_rule_idr;

	void idr_remove_uobj(struct idr idp, struct ib_uobject uobj);		void idr_remove_uobj(struct idr idp, struct ib_uobject uobj);

	@@ -215,5 +217,7 @@ IB_UVERBS_DECLARE_CMD(destroy_srq);
	IB_UVERBS_DECLARE_CMD(create_xsrq);		IB_UVERBS_DECLARE_CMD(create_xsrq);
	IB_UVERBS_DECLARE_CMD(open_xrcd);		IB_UVERBS_DECLARE_CMD(open_xrcd);
	IB_UVERBS_DECLARE_CMD(close_xrcd);		IB_UVERBS_DECLARE_CMD(close_xrcd);
			IB_UVERBS_DECLARE_CMD(create_flow);
			IB_UVERBS_DECLARE_CMD(destroy_flow);

	#endif /* UVERBS_H */		#endif /* UVERBS_H */

drivers/infiniband/core/uverbs_cmd.c

+248 −2

Original line number	Original line	Diff line number	Diff line
	@@ -54,6 +54,7 @@ static struct uverbs_lock_class qp_lock_class = { .name = "QP-uobj" };
	static struct uverbs_lock_class ah_lock_class = { .name = "AH-uobj" };		static struct uverbs_lock_class ah_lock_class = { .name = "AH-uobj" };
	static struct uverbs_lock_class srq_lock_class = { .name = "SRQ-uobj" };		static struct uverbs_lock_class srq_lock_class = { .name = "SRQ-uobj" };
	static struct uverbs_lock_class xrcd_lock_class = { .name = "XRCD-uobj" };		static struct uverbs_lock_class xrcd_lock_class = { .name = "XRCD-uobj" };
			static struct uverbs_lock_class rule_lock_class = { .name = "RULE-uobj" };

	#define INIT_UDATA(udata, ibuf, obuf, ilen, olen) \		#define INIT_UDATA(udata, ibuf, obuf, ilen, olen) \
	do { \		do { \
	@@ -330,6 +331,7 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
	INIT_LIST_HEAD(&ucontext->srq_list);		INIT_LIST_HEAD(&ucontext->srq_list);
	INIT_LIST_HEAD(&ucontext->ah_list);		INIT_LIST_HEAD(&ucontext->ah_list);
	INIT_LIST_HEAD(&ucontext->xrcd_list);		INIT_LIST_HEAD(&ucontext->xrcd_list);
			INIT_LIST_HEAD(&ucontext->rule_list);
	ucontext->closing = 0;		ucontext->closing = 0;

	resp.num_comp_vectors = file->device->num_comp_vectors;		resp.num_comp_vectors = file->device->num_comp_vectors;
	@@ -1526,7 +1528,7 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
	(unsigned long) cmd.response + sizeof resp,		(unsigned long) cmd.response + sizeof resp,
	in_len - sizeof cmd, out_len - sizeof resp);		in_len - sizeof cmd, out_len - sizeof resp);

	obj = kmalloc(sizeof *obj, GFP_KERNEL);		obj = kzalloc(sizeof *obj, GFP_KERNEL);
	if (!obj)		if (!obj)
	return -ENOMEM;		return -ENOMEM;

	@@ -1642,8 +1644,13 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
	goto err_copy;		goto err_copy;
	}		}

	if (xrcd)		if (xrcd) {
			obj->uxrcd = container_of(xrcd_uobj, struct ib_uxrcd_object,
			uobject);
			atomic_inc(&obj->uxrcd->refcnt);
	put_xrcd_read(xrcd_uobj);		put_xrcd_read(xrcd_uobj);
			}

	if (pd)		if (pd)
	put_pd_read(pd);		put_pd_read(pd);
	if (scq)		if (scq)
	@@ -1753,6 +1760,8 @@ ssize_t ib_uverbs_open_qp(struct ib_uverbs_file *file,
	goto err_remove;		goto err_remove;
	}		}

			obj->uxrcd = container_of(xrcd_uobj, struct ib_uxrcd_object, uobject);
			atomic_inc(&obj->uxrcd->refcnt);
	put_xrcd_read(xrcd_uobj);		put_xrcd_read(xrcd_uobj);

	mutex_lock(&file->mutex);		mutex_lock(&file->mutex);
	@@ -2019,6 +2028,9 @@ ssize_t ib_uverbs_destroy_qp(struct ib_uverbs_file *file,
	if (ret)		if (ret)
	return ret;		return ret;

			if (obj->uxrcd)
			atomic_dec(&obj->uxrcd->refcnt);

	idr_remove_uobj(&ib_uverbs_qp_idr, uobj);		idr_remove_uobj(&ib_uverbs_qp_idr, uobj);

	mutex_lock(&file->mutex);		mutex_lock(&file->mutex);
	@@ -2587,6 +2599,232 @@ out_put:
	return ret ? ret : in_len;		return ret ? ret : in_len;
	}		}

			static int kern_spec_to_ib_spec(struct ib_kern_spec *kern_spec,
			union ib_flow_spec *ib_spec)
			{
			ib_spec->type = kern_spec->type;

			switch (ib_spec->type) {
			case IB_FLOW_SPEC_ETH:
			ib_spec->eth.size = sizeof(struct ib_flow_spec_eth);
			if (ib_spec->eth.size != kern_spec->eth.size)
			return -EINVAL;
			memcpy(&ib_spec->eth.val, &kern_spec->eth.val,
			sizeof(struct ib_flow_eth_filter));
			memcpy(&ib_spec->eth.mask, &kern_spec->eth.mask,
			sizeof(struct ib_flow_eth_filter));
			break;
			case IB_FLOW_SPEC_IPV4:
			ib_spec->ipv4.size = sizeof(struct ib_flow_spec_ipv4);
			if (ib_spec->ipv4.size != kern_spec->ipv4.size)
			return -EINVAL;
			memcpy(&ib_spec->ipv4.val, &kern_spec->ipv4.val,
			sizeof(struct ib_flow_ipv4_filter));
			memcpy(&ib_spec->ipv4.mask, &kern_spec->ipv4.mask,
			sizeof(struct ib_flow_ipv4_filter));
			break;
			case IB_FLOW_SPEC_TCP:
			case IB_FLOW_SPEC_UDP:
			ib_spec->tcp_udp.size = sizeof(struct ib_flow_spec_tcp_udp);
			if (ib_spec->tcp_udp.size != kern_spec->tcp_udp.size)
			return -EINVAL;
			memcpy(&ib_spec->tcp_udp.val, &kern_spec->tcp_udp.val,
			sizeof(struct ib_flow_tcp_udp_filter));
			memcpy(&ib_spec->tcp_udp.mask, &kern_spec->tcp_udp.mask,
			sizeof(struct ib_flow_tcp_udp_filter));
			break;
			default:
			return -EINVAL;
			}
			return 0;
			}

			ssize_t ib_uverbs_create_flow(struct ib_uverbs_file *file,
			const char __user *buf, int in_len,
			int out_len)
			{
			struct ib_uverbs_create_flow cmd;
			struct ib_uverbs_create_flow_resp resp;
			struct ib_uobject *uobj;
			struct ib_flow *flow_id;
			struct ib_kern_flow_attr *kern_flow_attr;
			struct ib_flow_attr *flow_attr;
			struct ib_qp *qp;
			int err = 0;
			void *kern_spec;
			void *ib_spec;
			int i;
			int kern_attr_size;

			if (out_len < sizeof(resp))
			return -ENOSPC;

			if (copy_from_user(&cmd, buf, sizeof(cmd)))
			return -EFAULT;

			if (cmd.comp_mask)
			return -EINVAL;

			if ((cmd.flow_attr.type == IB_FLOW_ATTR_SNIFFER &&
			!capable(CAP_NET_ADMIN)) \|\| !capable(CAP_NET_RAW))
			return -EPERM;

			if (cmd.flow_attr.num_of_specs < 0 \|\|
			cmd.flow_attr.num_of_specs > IB_FLOW_SPEC_SUPPORT_LAYERS)
			return -EINVAL;

			kern_attr_size = cmd.flow_attr.size - sizeof(cmd) -
			sizeof(struct ib_uverbs_cmd_hdr_ex);

			if (cmd.flow_attr.size < 0 \|\| cmd.flow_attr.size > in_len \|\|
			kern_attr_size < 0 \|\| kern_attr_size >
			(cmd.flow_attr.num_of_specs * sizeof(struct ib_kern_spec)))
			return -EINVAL;

			if (cmd.flow_attr.num_of_specs) {
			kern_flow_attr = kmalloc(cmd.flow_attr.size, GFP_KERNEL);
			if (!kern_flow_attr)
			return -ENOMEM;

			memcpy(kern_flow_attr, &cmd.flow_attr, sizeof(*kern_flow_attr));
			if (copy_from_user(kern_flow_attr + 1, buf + sizeof(cmd),
			kern_attr_size)) {
			err = -EFAULT;
			goto err_free_attr;
			}
			} else {
			kern_flow_attr = &cmd.flow_attr;
			kern_attr_size = sizeof(cmd.flow_attr);
			}

			uobj = kmalloc(sizeof(*uobj), GFP_KERNEL);
			if (!uobj) {
			err = -ENOMEM;
			goto err_free_attr;
			}
			init_uobj(uobj, 0, file->ucontext, &rule_lock_class);
			down_write(&uobj->mutex);

			qp = idr_read_qp(cmd.qp_handle, file->ucontext);
			if (!qp) {
			err = -EINVAL;
			goto err_uobj;
			}

			flow_attr = kmalloc(cmd.flow_attr.size, GFP_KERNEL);
			if (!flow_attr) {
			err = -ENOMEM;
			goto err_put;
			}

			flow_attr->type = kern_flow_attr->type;
			flow_attr->priority = kern_flow_attr->priority;
			flow_attr->num_of_specs = kern_flow_attr->num_of_specs;
			flow_attr->port = kern_flow_attr->port;
			flow_attr->flags = kern_flow_attr->flags;
			flow_attr->size = sizeof(*flow_attr);

			kern_spec = kern_flow_attr + 1;
			ib_spec = flow_attr + 1;
			for (i = 0; i < flow_attr->num_of_specs && kern_attr_size > 0; i++) {
			err = kern_spec_to_ib_spec(kern_spec, ib_spec);
			if (err)
			goto err_free;
			flow_attr->size +=
			((union ib_flow_spec *) ib_spec)->size;
			kern_attr_size -= ((struct ib_kern_spec *) kern_spec)->size;
			kern_spec += ((struct ib_kern_spec *) kern_spec)->size;
			ib_spec += ((union ib_flow_spec *) ib_spec)->size;
			}
			if (kern_attr_size) {
			pr_warn("create flow failed, %d bytes left from uverb cmd\n",
			kern_attr_size);
			goto err_free;
			}
			flow_id = ib_create_flow(qp, flow_attr, IB_FLOW_DOMAIN_USER);
			if (IS_ERR(flow_id)) {
			err = PTR_ERR(flow_id);
			goto err_free;
			}
			flow_id->qp = qp;
			flow_id->uobject = uobj;
			uobj->object = flow_id;

			err = idr_add_uobj(&ib_uverbs_rule_idr, uobj);
			if (err)
			goto destroy_flow;

			memset(&resp, 0, sizeof(resp));
			resp.flow_handle = uobj->id;

			if (copy_to_user((void __user *)(unsigned long) cmd.response,
			&resp, sizeof(resp))) {
			err = -EFAULT;
			goto err_copy;
			}

			put_qp_read(qp);
			mutex_lock(&file->mutex);
			list_add_tail(&uobj->list, &file->ucontext->rule_list);
			mutex_unlock(&file->mutex);

			uobj->live = 1;

			up_write(&uobj->mutex);
			kfree(flow_attr);
			if (cmd.flow_attr.num_of_specs)
			kfree(kern_flow_attr);
			return in_len;
			err_copy:
			idr_remove_uobj(&ib_uverbs_rule_idr, uobj);
			destroy_flow:
			ib_destroy_flow(flow_id);
			err_free:
			kfree(flow_attr);
			err_put:
			put_qp_read(qp);
			err_uobj:
			put_uobj_write(uobj);
			err_free_attr:
			if (cmd.flow_attr.num_of_specs)
			kfree(kern_flow_attr);
			return err;
			}

			ssize_t ib_uverbs_destroy_flow(struct ib_uverbs_file *file,
			const char __user *buf, int in_len,
			int out_len) {
			struct ib_uverbs_destroy_flow cmd;
			struct ib_flow *flow_id;
			struct ib_uobject *uobj;
			int ret;

			if (copy_from_user(&cmd, buf, sizeof(cmd)))
			return -EFAULT;

			uobj = idr_write_uobj(&ib_uverbs_rule_idr, cmd.flow_handle,
			file->ucontext);
			if (!uobj)
			return -EINVAL;
			flow_id = uobj->object;

			ret = ib_destroy_flow(flow_id);
			if (!ret)
			uobj->live = 0;

			put_uobj_write(uobj);

			idr_remove_uobj(&ib_uverbs_rule_idr, uobj);

			mutex_lock(&file->mutex);
			list_del(&uobj->list);
			mutex_unlock(&file->mutex);

			put_uobj(uobj);

			return ret ? ret : in_len;
			}

	static int __uverbs_create_xsrq(struct ib_uverbs_file *file,		static int __uverbs_create_xsrq(struct ib_uverbs_file *file,
	struct ib_uverbs_create_xsrq *cmd,		struct ib_uverbs_create_xsrq *cmd,
	struct ib_udata *udata)		struct ib_udata *udata)
	@@ -2860,6 +3098,8 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
	struct ib_srq *srq;		struct ib_srq *srq;
	struct ib_uevent_object *obj;		struct ib_uevent_object *obj;
	int ret = -EINVAL;		int ret = -EINVAL;
			struct ib_usrq_object *us;
			enum ib_srq_type srq_type;

	if (copy_from_user(&cmd, buf, sizeof cmd))		if (copy_from_user(&cmd, buf, sizeof cmd))
	return -EFAULT;		return -EFAULT;
	@@ -2869,6 +3109,7 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
	return -EINVAL;		return -EINVAL;
	srq = uobj->object;		srq = uobj->object;
	obj = container_of(uobj, struct ib_uevent_object, uobject);		obj = container_of(uobj, struct ib_uevent_object, uobject);
			srq_type = srq->srq_type;

	ret = ib_destroy_srq(srq);		ret = ib_destroy_srq(srq);
	if (!ret)		if (!ret)
	@@ -2879,6 +3120,11 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
	if (ret)		if (ret)
	return ret;		return ret;

			if (srq_type == IB_SRQT_XRC) {
			us = container_of(obj, struct ib_usrq_object, uevent);
			atomic_dec(&us->uxrcd->refcnt);
			}

	idr_remove_uobj(&ib_uverbs_srq_idr, uobj);		idr_remove_uobj(&ib_uverbs_srq_idr, uobj);

	mutex_lock(&file->mutex);		mutex_lock(&file->mutex);

drivers/infiniband/core/uverbs_main.c

+36 −6

Original line number	Original line	Diff line number	Diff line
	@@ -73,6 +73,7 @@ DEFINE_IDR(ib_uverbs_cq_idr);
	DEFINE_IDR(ib_uverbs_qp_idr);		DEFINE_IDR(ib_uverbs_qp_idr);
	DEFINE_IDR(ib_uverbs_srq_idr);		DEFINE_IDR(ib_uverbs_srq_idr);
	DEFINE_IDR(ib_uverbs_xrcd_idr);		DEFINE_IDR(ib_uverbs_xrcd_idr);
			DEFINE_IDR(ib_uverbs_rule_idr);

	static DEFINE_SPINLOCK(map_lock);		static DEFINE_SPINLOCK(map_lock);
	static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES);		static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES);
	@@ -113,7 +114,9 @@ static ssize_t (uverbs_cmd_table[])(struct ib_uverbs_file file,
	[IB_USER_VERBS_CMD_OPEN_XRCD] = ib_uverbs_open_xrcd,		[IB_USER_VERBS_CMD_OPEN_XRCD] = ib_uverbs_open_xrcd,
	[IB_USER_VERBS_CMD_CLOSE_XRCD] = ib_uverbs_close_xrcd,		[IB_USER_VERBS_CMD_CLOSE_XRCD] = ib_uverbs_close_xrcd,
	[IB_USER_VERBS_CMD_CREATE_XSRQ] = ib_uverbs_create_xsrq,		[IB_USER_VERBS_CMD_CREATE_XSRQ] = ib_uverbs_create_xsrq,
	[IB_USER_VERBS_CMD_OPEN_QP] = ib_uverbs_open_qp		[IB_USER_VERBS_CMD_OPEN_QP] = ib_uverbs_open_qp,
			[IB_USER_VERBS_CMD_CREATE_FLOW] = ib_uverbs_create_flow,
			[IB_USER_VERBS_CMD_DESTROY_FLOW] = ib_uverbs_destroy_flow
	};		};

	static void ib_uverbs_add_one(struct ib_device *device);		static void ib_uverbs_add_one(struct ib_device *device);
	@@ -212,6 +215,14 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
	kfree(uobj);		kfree(uobj);
	}		}

			list_for_each_entry_safe(uobj, tmp, &context->rule_list, list) {
			struct ib_flow *flow_id = uobj->object;

			idr_remove_uobj(&ib_uverbs_rule_idr, uobj);
			ib_destroy_flow(flow_id);
			kfree(uobj);
			}

	list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) {		list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) {
	struct ib_qp *qp = uobj->object;		struct ib_qp *qp = uobj->object;
	struct ib_uqp_object *uqp =		struct ib_uqp_object *uqp =
	@@ -583,9 +594,6 @@ static ssize_t ib_uverbs_write(struct file filp, const char __user buf,
	if (copy_from_user(&hdr, buf, sizeof hdr))		if (copy_from_user(&hdr, buf, sizeof hdr))
	return -EFAULT;		return -EFAULT;

	if (hdr.in_words * 4 != count)
	return -EINVAL;

	if (hdr.command >= ARRAY_SIZE(uverbs_cmd_table) \|\|		if (hdr.command >= ARRAY_SIZE(uverbs_cmd_table) \|\|
	!uverbs_cmd_table[hdr.command])		!uverbs_cmd_table[hdr.command])
	return -EINVAL;		return -EINVAL;
	@@ -597,8 +605,30 @@ static ssize_t ib_uverbs_write(struct file filp, const char __user buf,
	if (!(file->device->ib_dev->uverbs_cmd_mask & (1ull << hdr.command)))		if (!(file->device->ib_dev->uverbs_cmd_mask & (1ull << hdr.command)))
	return -ENOSYS;		return -ENOSYS;

	return uverbs_cmd_table[hdr.command](file, buf + sizeof hdr,		if (hdr.command >= IB_USER_VERBS_CMD_THRESHOLD) {
	hdr.in_words * 4, hdr.out_words * 4);		struct ib_uverbs_cmd_hdr_ex hdr_ex;

			if (copy_from_user(&hdr_ex, buf, sizeof(hdr_ex)))
			return -EFAULT;

			if (((hdr_ex.in_words + hdr_ex.provider_in_words) * 4) != count)
			return -EINVAL;

			return uverbs_cmd_table[hdr.command](file,
			buf + sizeof(hdr_ex),
			(hdr_ex.in_words +
			hdr_ex.provider_in_words) * 4,
			(hdr_ex.out_words +
			hdr_ex.provider_out_words) * 4);
			} else {
			if (hdr.in_words * 4 != count)
			return -EINVAL;

			return uverbs_cmd_table[hdr.command](file,
			buf + sizeof(hdr),
			hdr.in_words * 4,
			hdr.out_words * 4);
			}
	}		}

	static int ib_uverbs_mmap(struct file filp, struct vm_area_struct vma)		static int ib_uverbs_mmap(struct file filp, struct vm_area_struct vma)

drivers/infiniband/core/verbs.c

+30 −0

Original line number	Original line	Diff line number	Diff line
	@@ -346,10 +346,13 @@ EXPORT_SYMBOL(ib_destroy_srq);
	static void __ib_shared_qp_event_handler(struct ib_event event, void context)		static void __ib_shared_qp_event_handler(struct ib_event event, void context)
	{		{
	struct ib_qp *qp = context;		struct ib_qp *qp = context;
			unsigned long flags;

			spin_lock_irqsave(&qp->device->event_handler_lock, flags);
	list_for_each_entry(event->element.qp, &qp->open_list, open_list)		list_for_each_entry(event->element.qp, &qp->open_list, open_list)
	if (event->element.qp->event_handler)		if (event->element.qp->event_handler)
	event->element.qp->event_handler(event, event->element.qp->qp_context);		event->element.qp->event_handler(event, event->element.qp->qp_context);
			spin_unlock_irqrestore(&qp->device->event_handler_lock, flags);
	}		}

	static void __ib_insert_xrcd_qp(struct ib_xrcd xrcd, struct ib_qp qp)		static void __ib_insert_xrcd_qp(struct ib_xrcd xrcd, struct ib_qp qp)
	@@ -1254,3 +1257,30 @@ int ib_dealloc_xrcd(struct ib_xrcd *xrcd)
	return xrcd->device->dealloc_xrcd(xrcd);		return xrcd->device->dealloc_xrcd(xrcd);
	}		}
	EXPORT_SYMBOL(ib_dealloc_xrcd);		EXPORT_SYMBOL(ib_dealloc_xrcd);

			struct ib_flow ib_create_flow(struct ib_qp qp,
			struct ib_flow_attr *flow_attr,
			int domain)
			{
			struct ib_flow *flow_id;
			if (!qp->device->create_flow)
			return ERR_PTR(-ENOSYS);

			flow_id = qp->device->create_flow(qp, flow_attr, domain);
			if (!IS_ERR(flow_id))
			atomic_inc(&qp->usecnt);
			return flow_id;
			}
			EXPORT_SYMBOL(ib_create_flow);

			int ib_destroy_flow(struct ib_flow *flow_id)
			{
			int err;
			struct ib_qp *qp = flow_id->qp;

			err = qp->device->destroy_flow(flow_id);
			if (!err)
			atomic_dec(&qp->usecnt);
			return err;
			}
			EXPORT_SYMBOL(ib_destroy_flow);

Admin message