Merge branches 'cxgb4', 'flowsteer', 'ipoib', 'iser', 'mlx4', 'ocrdma' and 'qib' into for-next (82af24ac) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/infiniband/core/uverbs.h

+4 −0

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

		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_srq_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);

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

		#endif /* UVERBS_H */

drivers/infiniband/core/uverbs_cmd.c

+248 −2

Original line number	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 srq_lock_class = { .name = "SRQ-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) \
		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->ah_list);
		INIT_LIST_HEAD(&ucontext->xrcd_list);
		INIT_LIST_HEAD(&ucontext->rule_list);
		ucontext->closing = 0;

		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,
		in_len - sizeof cmd, out_len - sizeof resp);

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

		@@ -1642,8 +1644,13 @@ ssize_t ib_uverbs_create_qp(struct ib_uverbs_file *file,
		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);
		}

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

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

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

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

		idr_remove_uobj(&ib_uverbs_qp_idr, uobj);

		mutex_lock(&file->mutex);
		@@ -2587,6 +2599,232 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file,
		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,
		struct ib_uverbs_create_xsrq *cmd,
		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_uevent_object *obj;
		int ret = -EINVAL;
		struct ib_usrq_object *us;
		enum ib_srq_type srq_type;

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

		ret = ib_destroy_srq(srq);
		if (!ret)
		@@ -2879,6 +3120,11 @@ ssize_t ib_uverbs_destroy_srq(struct ib_uverbs_file *file,
		if (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);

		mutex_lock(&file->mutex);

drivers/infiniband/core/uverbs_main.c

+36 −6

Original line number	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_srq_idr);
		DEFINE_IDR(ib_uverbs_xrcd_idr);
		DEFINE_IDR(ib_uverbs_rule_idr);

		static DEFINE_SPINLOCK(map_lock);
		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_CLOSE_XRCD] = ib_uverbs_close_xrcd,
		[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);
		@@ -212,6 +215,14 @@ static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
		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) {
		struct ib_qp *qp = uobj->object;
		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))
		return -EFAULT;

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

		if (hdr.command >= ARRAY_SIZE(uverbs_cmd_table) \|\|
		!uverbs_cmd_table[hdr.command])
		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)))
		return -ENOSYS;

		return uverbs_cmd_table[hdr.command](file, buf + sizeof hdr,
		hdr.in_words * 4, hdr.out_words * 4);
		if (hdr.command >= IB_USER_VERBS_CMD_THRESHOLD) {
		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)

drivers/infiniband/core/verbs.c

+30 −0

Original line number	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)
		{
		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)
		if (event->element.qp->event_handler)
		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)
		@@ -1254,3 +1257,30 @@ int ib_dealloc_xrcd(struct ib_xrcd *xrcd)
		return xrcd->device->dealloc_xrcd(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);

drivers/infiniband/hw/mlx4/main.c

+235 −0

Original line number	Diff line number	Diff line
		@@ -54,6 +54,8 @@
		#define DRV_VERSION "1.0"
		#define DRV_RELDATE "April 4, 2008"

		#define MLX4_IB_FLOW_MAX_PRIO 0xFFF

		MODULE_AUTHOR("Roland Dreier");
		MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
		MODULE_LICENSE("Dual BSD/GPL");
		@@ -88,6 +90,25 @@ static void init_query_mad(struct ib_smp *mad)

		static union ib_gid zgid;

		static int check_flow_steering_support(struct mlx4_dev *dev)
		{
		int ib_num_ports = 0;
		int i;

		mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
		ib_num_ports++;

		if (dev->caps.steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
		if (ib_num_ports \|\| mlx4_is_mfunc(dev)) {
		pr_warn("Device managed flow steering is unavailable "
		"for IB ports or in multifunction env.\n");
		return 0;
		}
		return 1;
		}
		return 0;
		}

		static int mlx4_ib_query_device(struct ib_device *ibdev,
		struct ib_device_attr *props)
		{
		@@ -144,6 +165,8 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
		props->device_cap_flags \|= IB_DEVICE_MEM_WINDOW_TYPE_2B;
		else
		props->device_cap_flags \|= IB_DEVICE_MEM_WINDOW_TYPE_2A;
		if (check_flow_steering_support(dev->dev))
		props->device_cap_flags \|= IB_DEVICE_MANAGED_FLOW_STEERING;
		}

		props->vendor_id = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
		@@ -798,6 +821,209 @@ struct mlx4_ib_steering {
		union ib_gid gid;
		};

		static int parse_flow_attr(struct mlx4_dev *dev,
		union ib_flow_spec *ib_spec,
		struct _rule_hw *mlx4_spec)
		{
		enum mlx4_net_trans_rule_id type;

		switch (ib_spec->type) {
		case IB_FLOW_SPEC_ETH:
		type = MLX4_NET_TRANS_RULE_ID_ETH;
		memcpy(mlx4_spec->eth.dst_mac, ib_spec->eth.val.dst_mac,
		ETH_ALEN);
		memcpy(mlx4_spec->eth.dst_mac_msk, ib_spec->eth.mask.dst_mac,
		ETH_ALEN);
		mlx4_spec->eth.vlan_tag = ib_spec->eth.val.vlan_tag;
		mlx4_spec->eth.vlan_tag_msk = ib_spec->eth.mask.vlan_tag;
		break;

		case IB_FLOW_SPEC_IPV4:
		type = MLX4_NET_TRANS_RULE_ID_IPV4;
		mlx4_spec->ipv4.src_ip = ib_spec->ipv4.val.src_ip;
		mlx4_spec->ipv4.src_ip_msk = ib_spec->ipv4.mask.src_ip;
		mlx4_spec->ipv4.dst_ip = ib_spec->ipv4.val.dst_ip;
		mlx4_spec->ipv4.dst_ip_msk = ib_spec->ipv4.mask.dst_ip;
		break;

		case IB_FLOW_SPEC_TCP:
		case IB_FLOW_SPEC_UDP:
		type = ib_spec->type == IB_FLOW_SPEC_TCP ?
		MLX4_NET_TRANS_RULE_ID_TCP :
		MLX4_NET_TRANS_RULE_ID_UDP;
		mlx4_spec->tcp_udp.dst_port = ib_spec->tcp_udp.val.dst_port;
		mlx4_spec->tcp_udp.dst_port_msk = ib_spec->tcp_udp.mask.dst_port;
		mlx4_spec->tcp_udp.src_port = ib_spec->tcp_udp.val.src_port;
		mlx4_spec->tcp_udp.src_port_msk = ib_spec->tcp_udp.mask.src_port;
		break;

		default:
		return -EINVAL;
		}
		if (mlx4_map_sw_to_hw_steering_id(dev, type) < 0 \|\|
		mlx4_hw_rule_sz(dev, type) < 0)
		return -EINVAL;
		mlx4_spec->id = cpu_to_be16(mlx4_map_sw_to_hw_steering_id(dev, type));
		mlx4_spec->size = mlx4_hw_rule_sz(dev, type) >> 2;
		return mlx4_hw_rule_sz(dev, type);
		}

		static int __mlx4_ib_create_flow(struct ib_qp qp, struct ib_flow_attr flow_attr,
		int domain,
		enum mlx4_net_trans_promisc_mode flow_type,
		u64 *reg_id)
		{
		int ret, i;
		int size = 0;
		void *ib_flow;
		struct mlx4_ib_dev *mdev = to_mdev(qp->device);
		struct mlx4_cmd_mailbox *mailbox;
		struct mlx4_net_trans_rule_hw_ctrl *ctrl;
		size_t rule_size = sizeof(struct mlx4_net_trans_rule_hw_ctrl) +
		(sizeof(struct _rule_hw) * flow_attr->num_of_specs);

		static const u16 __mlx4_domain[] = {
		[IB_FLOW_DOMAIN_USER] = MLX4_DOMAIN_UVERBS,
		[IB_FLOW_DOMAIN_ETHTOOL] = MLX4_DOMAIN_ETHTOOL,
		[IB_FLOW_DOMAIN_RFS] = MLX4_DOMAIN_RFS,
		[IB_FLOW_DOMAIN_NIC] = MLX4_DOMAIN_NIC,
		};

		if (flow_attr->priority > MLX4_IB_FLOW_MAX_PRIO) {
		pr_err("Invalid priority value %d\n", flow_attr->priority);
		return -EINVAL;
		}

		if (domain >= IB_FLOW_DOMAIN_NUM) {
		pr_err("Invalid domain value %d\n", domain);
		return -EINVAL;
		}

		if (mlx4_map_sw_to_hw_steering_mode(mdev->dev, flow_type) < 0)
		return -EINVAL;

		mailbox = mlx4_alloc_cmd_mailbox(mdev->dev);
		if (IS_ERR(mailbox))
		return PTR_ERR(mailbox);
		memset(mailbox->buf, 0, rule_size);
		ctrl = mailbox->buf;

		ctrl->prio = cpu_to_be16(__mlx4_domain[domain] \|
		flow_attr->priority);
		ctrl->type = mlx4_map_sw_to_hw_steering_mode(mdev->dev, flow_type);
		ctrl->port = flow_attr->port;
		ctrl->qpn = cpu_to_be32(qp->qp_num);

		ib_flow = flow_attr + 1;
		size += sizeof(struct mlx4_net_trans_rule_hw_ctrl);
		for (i = 0; i < flow_attr->num_of_specs; i++) {
		ret = parse_flow_attr(mdev->dev, ib_flow, mailbox->buf + size);
		if (ret < 0) {
		mlx4_free_cmd_mailbox(mdev->dev, mailbox);
		return -EINVAL;
		}
		ib_flow += ((union ib_flow_spec *) ib_flow)->size;
		size += ret;
		}

		ret = mlx4_cmd_imm(mdev->dev, mailbox->dma, reg_id, size >> 2, 0,
		MLX4_QP_FLOW_STEERING_ATTACH, MLX4_CMD_TIME_CLASS_A,
		MLX4_CMD_NATIVE);
		if (ret == -ENOMEM)
		pr_err("mcg table is full. Fail to register network rule.\n");
		else if (ret == -ENXIO)
		pr_err("Device managed flow steering is disabled. Fail to register network rule.\n");
		else if (ret)
		pr_err("Invalid argumant. Fail to register network rule.\n");

		mlx4_free_cmd_mailbox(mdev->dev, mailbox);
		return ret;
		}

		static int __mlx4_ib_destroy_flow(struct mlx4_dev *dev, u64 reg_id)
		{
		int err;
		err = mlx4_cmd(dev, reg_id, 0, 0,
		MLX4_QP_FLOW_STEERING_DETACH, MLX4_CMD_TIME_CLASS_A,
		MLX4_CMD_NATIVE);
		if (err)
		pr_err("Fail to detach network rule. registration id = 0x%llx\n",
		reg_id);
		return err;
		}

		static struct ib_flow mlx4_ib_create_flow(struct ib_qp qp,
		struct ib_flow_attr *flow_attr,
		int domain)
		{
		int err = 0, i = 0;
		struct mlx4_ib_flow *mflow;
		enum mlx4_net_trans_promisc_mode type[2];

		memset(type, 0, sizeof(type));

		mflow = kzalloc(sizeof(*mflow), GFP_KERNEL);
		if (!mflow) {
		err = -ENOMEM;
		goto err_free;
		}

		switch (flow_attr->type) {
		case IB_FLOW_ATTR_NORMAL:
		type[0] = MLX4_FS_REGULAR;
		break;

		case IB_FLOW_ATTR_ALL_DEFAULT:
		type[0] = MLX4_FS_ALL_DEFAULT;
		break;

		case IB_FLOW_ATTR_MC_DEFAULT:
		type[0] = MLX4_FS_MC_DEFAULT;
		break;

		case IB_FLOW_ATTR_SNIFFER:
		type[0] = MLX4_FS_UC_SNIFFER;
		type[1] = MLX4_FS_MC_SNIFFER;
		break;

		default:
		err = -EINVAL;
		goto err_free;
		}

		while (i < ARRAY_SIZE(type) && type[i]) {
		err = __mlx4_ib_create_flow(qp, flow_attr, domain, type[i],
		&mflow->reg_id[i]);
		if (err)
		goto err_free;
		i++;
		}

		return &mflow->ibflow;

		err_free:
		kfree(mflow);
		return ERR_PTR(err);
		}

		static int mlx4_ib_destroy_flow(struct ib_flow *flow_id)
		{
		int err, ret = 0;
		int i = 0;
		struct mlx4_ib_dev *mdev = to_mdev(flow_id->qp->device);
		struct mlx4_ib_flow *mflow = to_mflow(flow_id);

		while (i < ARRAY_SIZE(mflow->reg_id) && mflow->reg_id[i]) {
		err = __mlx4_ib_destroy_flow(mdev->dev, mflow->reg_id[i]);
		if (err)
		ret = err;
		i++;
		}

		kfree(mflow);
		return ret;
		}

		static int mlx4_ib_mcg_attach(struct ib_qp ibqp, union ib_gid gid, u16 lid)
		{
		int err;
		@@ -1461,6 +1687,15 @@ static void mlx4_ib_add(struct mlx4_dev dev)
		(1ull << IB_USER_VERBS_CMD_CLOSE_XRCD);
		}

		if (check_flow_steering_support(dev)) {
		ibdev->ib_dev.create_flow = mlx4_ib_create_flow;
		ibdev->ib_dev.destroy_flow = mlx4_ib_destroy_flow;

		ibdev->ib_dev.uverbs_cmd_mask \|=
		(1ull << IB_USER_VERBS_CMD_CREATE_FLOW) \|
		(1ull << IB_USER_VERBS_CMD_DESTROY_FLOW);
		}

		mlx4_ib_alloc_eqs(dev, ibdev);

		spin_lock_init(&iboe->lock);