Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma

Pull rdma fixes from Doug Ledford: "This has been a slow -rc cycle for the RDMA subsystem. We really haven't had a lot of rc fixes come in. This pull request is the first of this entire rc cycle and it has all of the suitable fixes so far and it's still only about 20 patches. The fix for the minor breakage cause by the dma mapping patchset is in here, as well as a couple other potential oops fixes, but the rest is more minor. Summary: - fix for dma_ops change in this kernel, resolving the s390, powerpc, and IOMMU operation - a few other oops fixes - the rest are all minor fixes" * tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma: IB/qib: fix false-postive maybe-uninitialized warning RDMA/iser: Fix possible mr leak on device removal event IB/device: Convert ib-comp-wq to be CPU-bound IB/cq: Don't process more than the given budget IB/rxe: increment msn only when completing a request uapi: fix rdma/mlx5-abi.h userspace compilation errors IB/core: Restore I/O MMU, s390 and powerpc support IB/rxe: Update documentation link RDMA/ocrdma: fix a type issue in ocrdma_put_pd_num() IB/rxe: double free on error RDMA/vmw_pvrdma: Activate device on ethernet link up RDMA/vmw_pvrdma: Dont hardcode QP header page RDMA/vmw_pvrdma: Cleanup unused variables infiniband: Fix alignment of mmap cookies to support VIPT caching IB/core: Protect against self-requeue of a cq work item i40iw: Receive netdev events post INET_NOTIFIER state

Linus Torvalds committed 9 years ago

Commit 4a01fa52 parents 4c3de7e f6aafac18 files · +110 −69Browse files

Unified · Split

18 files

drivers/infiniband/core/cq.c +8 −2
drivers/infiniband/core/device.c +21 −8
drivers/infiniband/hw/i40iw/i40iw_utils.c +8 −0
drivers/infiniband/hw/ocrdma/ocrdma_verbs.c +1 −1
drivers/infiniband/hw/qib/qib_iba7322.c +1 −1
drivers/infiniband/hw/vmw_pvrdma/pvrdma.h +3 −0
drivers/infiniband/hw/vmw_pvrdma/pvrdma_dev_api.h +1 −1
drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c +13 −4
drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c +18 −24
drivers/infiniband/sw/rdmavt/mmap.c +2 −2
drivers/infiniband/sw/rxe/Kconfig +1 −1
drivers/infiniband/sw/rxe/rxe_mmap.c +2 −2
drivers/infiniband/sw/rxe/rxe_req.c +1 −1
drivers/infiniband/sw/rxe/rxe_resp.c +4 −5
drivers/infiniband/ulp/iser/iscsi_iser.h +2 −0
drivers/infiniband/ulp/iser/iser_verbs.c +5 −3
include/rdma/ib_verbs.h +17 −13
include/uapi/rdma/mlx5-abi.h +2 −1

drivers/infiniband/core/cq.c+8−2

 {
 	int i, n, completed = 0;
-	while ((n = ib_poll_cq(cq, IB_POLL_BATCH, cq->wc)) > 0) {
+	/*
+	 * budget might be (-1) if the caller does not
+	 * want to bound this call, thus we need unsigned
+	 * minimum here.
+	 */
+	while ((n = ib_poll_cq(cq, min_t(u32, IB_POLL_BATCH,
+			budget - completed), cq->wc)) > 0) {
 		for (i = 0; i < n; i++) {
 			struct ib_wc *wc = &cq->wc[i];
 		irq_poll_disable(&cq->iop);
 		break;
 	case IB_POLL_WORKQUEUE:
-		flush_work(&cq->work);
+		cancel_work_sync(&cq->work);
 		break;
 	default:
 		WARN_ON_ONCE(1);

drivers/infiniband/core/device.c+21−8

 	struct device *parent = device->dev.parent;
 	WARN_ON_ONCE(!parent);
-	if (!device->dev.dma_ops)
+	WARN_ON_ONCE(device->dma_device);
-		device->dev.dma_ops = parent->dma_ops;
+	if (device->dev.dma_ops) {
-	if (!device->dev.dma_mask)
+		/*
-		device->dev.dma_mask = parent->dma_mask;
+		 * The caller provided custom DMA operations. Copy the
-	if (!device->dev.coherent_dma_mask)
+		 * DMA-related fields that are used by e.g. dma_alloc_coherent()
-		device->dev.coherent_dma_mask = parent->coherent_dma_mask;
+		 * into device->dev.
+		 */
+		device->dma_device = &device->dev;
+		if (!device->dev.dma_mask)
+			device->dev.dma_mask = parent->dma_mask;
+		if (!device->dev.coherent_dma_mask)
+			device->dev.coherent_dma_mask =
+				parent->coherent_dma_mask;
+	} else {
+		/*
+		 * The caller did not provide custom DMA operations. Use the
+		 * DMA mapping operations of the parent device.
+		 */
+		device->dma_device = parent;
+	}
 	mutex_lock(&device_mutex);
 		return -ENOMEM;
 	ib_comp_wq = alloc_workqueue("ib-comp-wq",
-			WQ_UNBOUND | WQ_HIGHPRI | WQ_MEM_RECLAIM,
+			WQ_HIGHPRI | WQ_MEM_RECLAIM | WQ_SYSFS, 0);
-			WQ_UNBOUND_MAX_ACTIVE);
 	if (!ib_comp_wq) {
 		ret = -ENOMEM;
 		goto err;

drivers/infiniband/hw/i40iw/i40iw_utils.c+8−0

 		return NOTIFY_DONE;
 	iwdev = &hdl->device;
+	if (iwdev->init_state < INET_NOTIFIER)
+		return NOTIFY_DONE;
 	netdev = iwdev->ldev->netdev;
 	upper_dev = netdev_master_upper_dev_get(netdev);
 	if (netdev != event_netdev)
 		return NOTIFY_DONE;
 	iwdev = &hdl->device;
+	if (iwdev->init_state < INET_NOTIFIER)
+		return NOTIFY_DONE;
 	netdev = iwdev->ldev->netdev;
 	if (netdev != event_netdev)
 		return NOTIFY_DONE;
 		if (!iwhdl)
 			return NOTIFY_DONE;
 		iwdev = &iwhdl->device;
+		if (iwdev->init_state < INET_NOTIFIER)
+			return NOTIFY_DONE;
 		p = (__be32 *)neigh->primary_key;
 		i40iw_copy_ip_ntohl(local_ipaddr, p);
 		if (neigh->nud_state & NUD_VALID) {

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c+1−1

@@ -372,7 +372,7 @@ static int _ocrdma_pd_mgr_put_bitmap(struct ocrdma_dev *dev, u16 pd_id, · 371 unmodified lines
372	return 0;	372	return 0;
373	}	373	}
374		374
375	static u8 ocrdma_put_pd_num(struct ocrdma_dev *dev, u16 pd_id,	375	static int ocrdma_put_pd_num(struct ocrdma_dev *dev, u16 pd_id,
376	bool dpp_pool)	376	bool dpp_pool)
377	{	377	{
378	int status;	378	int status;

drivers/infiniband/hw/qib/qib_iba7322.c+1−1

@@ -7068,7 +7068,7 @@ static void qib_7322_txchk_change(struct qib_devdata *dd, u32 start, · 7067 unmodified lines
7068	unsigned long flags;	7068	unsigned long flags;
7069		7069
7070	while (wait) {	7070	while (wait) {
7071	unsigned long shadow;	7071	unsigned long shadow = 0;
7072	int cstart, previ = -1;	7072	int cstart, previ = -1;
7073		7073
7074	/*	7074	/*

drivers/infiniband/hw/vmw_pvrdma/pvrdma.h+3−0

@@ -69,6 +69,9 @@ · 68 unmodified lines
69	*/	69	*/
70	#define PCI_DEVICE_ID_VMWARE_PVRDMA 0x0820	70	#define PCI_DEVICE_ID_VMWARE_PVRDMA 0x0820
71		71
		72	#define PVRDMA_NUM_RING_PAGES 4
		73	#define PVRDMA_QP_NUM_HEADER_PAGES 1
		74
72	struct pvrdma_dev;	75	struct pvrdma_dev;
73		76
74	struct pvrdma_page_dir {	77	struct pvrdma_page_dir {

drivers/infiniband/hw/vmw_pvrdma/pvrdma_dev_api.h+1−1

@@ -132,7 +132,7 @@ enum pvrdma_pci_resource { · 131 unmodified lines
132		132
133	enum pvrdma_device_ctl {	133	enum pvrdma_device_ctl {
134	PVRDMA_DEVICE_CTL_ACTIVATE, /* Activate device. */	134	PVRDMA_DEVICE_CTL_ACTIVATE, /* Activate device. */
135	PVRDMA_DEVICE_CTL_QUIESCE, /* Quiesce device. */	135	PVRDMA_DEVICE_CTL_UNQUIESCE, /* Unquiesce device. */
136	PVRDMA_DEVICE_CTL_RESET, /* Reset device. */	136	PVRDMA_DEVICE_CTL_RESET, /* Reset device. */
137	};	137	};
138		138

drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c+13−4

 #include "pvrdma.h"
 #define DRV_NAME	"vmw_pvrdma"
-#define DRV_VERSION	"1.0.0.0-k"
+#define DRV_VERSION	"1.0.1.0-k"
 static DEFINE_MUTEX(pvrdma_device_list_lock);
 static LIST_HEAD(pvrdma_device_list);
 		pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ERR);
 		break;
 	case NETDEV_UP:
-		pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ACTIVE);
+		pvrdma_write_reg(dev, PVRDMA_REG_CTL,
+				 PVRDMA_DEVICE_CTL_UNQUIESCE);
+		mb();
+		if (pvrdma_read_reg(dev, PVRDMA_REG_ERR))
+			dev_err(&dev->pdev->dev,
+				"failed to activate device during link up\n");
+		else
+			pvrdma_dispatch_event(dev, 1, IB_EVENT_PORT_ACTIVE);
 		break;
 	default:
 		dev_dbg(&dev->pdev->dev, "ignore netdevice event %ld on %s\n",
 	dev->dsr->resp_slot_dma = (u64)slot_dma;
 	/* Async event ring */
-	dev->dsr->async_ring_pages.num_pages = 4;
+	dev->dsr->async_ring_pages.num_pages = PVRDMA_NUM_RING_PAGES;
 	ret = pvrdma_page_dir_init(dev, &dev->async_pdir,
 				   dev->dsr->async_ring_pages.num_pages, true);
 	if (ret)
 	dev->dsr->async_ring_pages.pdir_dma = dev->async_pdir.dir_dma;
 	/* CQ notification ring */
-	dev->dsr->cq_ring_pages.num_pages = 4;
+	dev->dsr->cq_ring_pages.num_pages = PVRDMA_NUM_RING_PAGES;
 	ret = pvrdma_page_dir_init(dev, &dev->cq_pdir,
 				   dev->dsr->cq_ring_pages.num_pages, true);
 	if (ret)

drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c+18−24

 					     sizeof(struct pvrdma_sge) *
 					     qp->sq.max_sg);
 	/* Note: one extra page for the header. */
-	qp->npages_send = 1 + (qp->sq.wqe_cnt * qp->sq.wqe_size +
+	qp->npages_send = PVRDMA_QP_NUM_HEADER_PAGES +
-			       PAGE_SIZE - 1) / PAGE_SIZE;
+			  (qp->sq.wqe_cnt * qp->sq.wqe_size + PAGE_SIZE - 1) /
+								PAGE_SIZE;
 	return 0;
 }
 			qp->npages = qp->npages_send + qp->npages_recv;
 			/* Skip header page. */
-			qp->sq.offset = PAGE_SIZE;
+			qp->sq.offset = PVRDMA_QP_NUM_HEADER_PAGES * PAGE_SIZE;
 			/* Recv queue pages are after send pages. */
 			qp->rq.offset = qp->npages_send * PAGE_SIZE;
 	cmd->qp_type = ib_qp_type_to_pvrdma(init_attr->qp_type);
 	cmd->access_flags = IB_ACCESS_LOCAL_WRITE;
 	cmd->total_chunks = qp->npages;
-	cmd->send_chunks = qp->npages_send - 1;
+	cmd->send_chunks = qp->npages_send - PVRDMA_QP_NUM_HEADER_PAGES;
 	cmd->pdir_dma = qp->pdir.dir_dma;
 	dev_dbg(&dev->pdev->dev, "create queuepair with %d, %d, %d, %d\n",
 	return ret;
 }
-static inline void *get_sq_wqe(struct pvrdma_qp *qp, int n)
+static inline void *get_sq_wqe(struct pvrdma_qp *qp, unsigned int n)
 {
 	return pvrdma_page_dir_get_ptr(&qp->pdir,
 				       qp->sq.offset + n * qp->sq.wqe_size);
 }
-static inline void *get_rq_wqe(struct pvrdma_qp *qp, int n)
+static inline void *get_rq_wqe(struct pvrdma_qp *qp, unsigned int n)
 {
 	return pvrdma_page_dir_get_ptr(&qp->pdir,
 				       qp->rq.offset + n * qp->rq.wqe_size);
 	unsigned long flags;
 	struct pvrdma_sq_wqe_hdr *wqe_hdr;
 	struct pvrdma_sge *sge;
-	int i, index;
+	int i, ret;
-	int nreq;
-	int ret;
 	/*
 	 * In states lower than RTS, we can fail immediately. In other states,
 	spin_lock_irqsave(&qp->sq.lock, flags);
-	index = pvrdma_idx(&qp->sq.ring->prod_tail, qp->sq.wqe_cnt);
+	while (wr) {
-	for (nreq = 0; wr; nreq++, wr = wr->next) {
+		unsigned int tail = 0;
-		unsigned int tail;
 		if (unlikely(!pvrdma_idx_ring_has_space(
 				qp->sq.ring, qp->sq.wqe_cnt, &tail))) {
 			}
 		}
-		wqe_hdr = (struct pvrdma_sq_wqe_hdr *)get_sq_wqe(qp, index);
+		wqe_hdr = (struct pvrdma_sq_wqe_hdr *)get_sq_wqe(qp, tail);
 		memset(wqe_hdr, 0, sizeof(*wqe_hdr));
 		wqe_hdr->wr_id = wr->wr_id;
 		wqe_hdr->num_sge = wr->num_sge;
 		/* Make sure wqe is written before index update */
 		smp_wmb();
-		index++;
-		if (unlikely(index >= qp->sq.wqe_cnt))
-			index = 0;
 		/* Update shared sq ring */
 		pvrdma_idx_ring_inc(&qp->sq.ring->prod_tail,
 				    qp->sq.wqe_cnt);
+		wr = wr->next;
 	}
 	ret = 0;
 	struct pvrdma_qp *qp = to_vqp(ibqp);
 	struct pvrdma_rq_wqe_hdr *wqe_hdr;
 	struct pvrdma_sge *sge;
-	int index, nreq;
 	int ret = 0;
 	int i;
 	spin_lock_irqsave(&qp->rq.lock, flags);
-	index = pvrdma_idx(&qp->rq.ring->prod_tail, qp->rq.wqe_cnt);
+	while (wr) {
-	for (nreq = 0; wr; nreq++, wr = wr->next) {
+		unsigned int tail = 0;
-		unsigned int tail;
 		if (unlikely(wr->num_sge > qp->rq.max_sg ||
 			     wr->num_sge < 0)) {
 			goto out;
 		}
-		wqe_hdr = (struct pvrdma_rq_wqe_hdr *)get_rq_wqe(qp, index);
+		wqe_hdr = (struct pvrdma_rq_wqe_hdr *)get_rq_wqe(qp, tail);
 		wqe_hdr->wr_id = wr->wr_id;
 		wqe_hdr->num_sge = wr->num_sge;
 		wqe_hdr->total_len = 0;
 		/* Make sure wqe is written before index update */
 		smp_wmb();
-		index++;
-		if (unlikely(index >= qp->rq.wqe_cnt))
-			index = 0;
 		/* Update shared rq ring */
 		pvrdma_idx_ring_inc(&qp->rq.ring->prod_tail,
 				    qp->rq.wqe_cnt);
+		wr = wr->next;
 	}
 	spin_unlock_irqrestore(&qp->rq.lock, flags);

drivers/infiniband/sw/rdmavt/mmap.c+2−2

@@ -170,9 +170,9 @@ struct rvt_mmap_info rvt_create_mmap_info(struct rvt_dev_info rdi, · 169 unmodified lines
170		170
171	spin_lock_irq(&rdi->mmap_offset_lock);	171	spin_lock_irq(&rdi->mmap_offset_lock);
172	if (rdi->mmap_offset == 0)	172	if (rdi->mmap_offset == 0)
173	rdi->mmap_offset = PAGE_SIZE;	173	rdi->mmap_offset = ALIGN(PAGE_SIZE, SHMLBA);
174	ip->offset = rdi->mmap_offset;	174	ip->offset = rdi->mmap_offset;
175	rdi->mmap_offset += size;	175	rdi->mmap_offset += ALIGN(size, SHMLBA);
176	spin_unlock_irq(&rdi->mmap_offset_lock);	176	spin_unlock_irq(&rdi->mmap_offset_lock);
177		177
178	INIT_LIST_HEAD(&ip->pending_mmaps);	178	INIT_LIST_HEAD(&ip->pending_mmaps);

drivers/infiniband/sw/rxe/Kconfig+1−1

@@ -22,4 +22,4 @@ config RDMA_RXE · 21 unmodified lines
22	To configure and work with soft-RoCE driver please use the	22	To configure and work with soft-RoCE driver please use the
23	following wiki page under "configure Soft-RoCE (RXE)" section:	23	following wiki page under "configure Soft-RoCE (RXE)" section:
24		24
25	https://github.com/SoftRoCE/rxe-dev/wiki/rxe-dev:-Home	25	https://github.com/linux-rdma/rdma-core/blob/master/Documentation/rxe.md

drivers/infiniband/sw/rxe/rxe_mmap.c+2−2

@@ -156,10 +156,10 @@ struct rxe_mmap_info rxe_create_mmap_info(struct rxe_dev rxe, · 155 unmodified lines
156	spin_lock_bh(&rxe->mmap_offset_lock);	156	spin_lock_bh(&rxe->mmap_offset_lock);
157		157
158	if (rxe->mmap_offset == 0)	158	if (rxe->mmap_offset == 0)
159	rxe->mmap_offset = PAGE_SIZE;	159	rxe->mmap_offset = ALIGN(PAGE_SIZE, SHMLBA);
160		160
161	ip->info.offset = rxe->mmap_offset;	161	ip->info.offset = rxe->mmap_offset;
162	rxe->mmap_offset += size;	162	rxe->mmap_offset += ALIGN(size, SHMLBA);
163		163
164	spin_unlock_bh(&rxe->mmap_offset_lock);	164	spin_unlock_bh(&rxe->mmap_offset_lock);
165		165

drivers/infiniband/sw/rxe/rxe_req.c+1−1

 	ret = rxe_xmit_packet(to_rdev(qp->ibqp.device), qp, &pkt, skb);
 	if (ret) {
 		qp->need_req_skb = 1;
-		kfree_skb(skb);
 		rollback_state(wqe, qp, &rollback_wqe, rollback_psn);
 		if (ret == -EAGAIN) {
+			kfree_skb(skb);
 			rxe_run_task(&qp->req.task, 1);
 			goto exit;
 		}

drivers/infiniband/sw/rxe/rxe_resp.c+4−5

 		WARN_ON_ONCE(1);
 	}
-	/* We successfully processed this new request. */
-	qp->resp.msn++;
 	/* next expected psn, read handles this separately */
 	qp->resp.psn = (pkt->psn + 1) & BTH_PSN_MASK;
 	qp->resp.opcode = pkt->opcode;
 	qp->resp.status = IB_WC_SUCCESS;
-	if (pkt->mask & RXE_COMP_MASK)
+	if (pkt->mask & RXE_COMP_MASK) {
+		/* We successfully processed this new request. */
+		qp->resp.msn++;
 		return RESPST_COMPLETE;
-	else if (qp_type(qp) == IB_QPT_RC)
+	} else if (qp_type(qp) == IB_QPT_RC)
 		return RESPST_ACKNOWLEDGE;
 	else
 		return RESPST_CLEANUP;

drivers/infiniband/ulp/iser/iscsi_iser.h+2−0

 	struct list_head		  list;
 	struct iser_reg_resources	  rsc;
 	struct iser_pi_context		 *pi_ctx;
+	struct list_head                  all_list;
 };
 /**
 	struct list_head        list;
 	spinlock_t              lock;
 	int                     size;
+	struct list_head        all_list;
 };
 /**

drivers/infiniband/ulp/iser/iser_verbs.c+5−3

 	int i, ret;
 	INIT_LIST_HEAD(&fr_pool->list);
+	INIT_LIST_HEAD(&fr_pool->all_list);
 	spin_lock_init(&fr_pool->lock);
 	fr_pool->size = 0;
 	for (i = 0; i < cmds_max; i++) {
 		}
 		list_add_tail(&desc->list, &fr_pool->list);
+		list_add_tail(&desc->all_list, &fr_pool->all_list);
 		fr_pool->size++;
 	}
 	struct iser_fr_desc *desc, *tmp;
 	int i = 0;
-	if (list_empty(&fr_pool->list))
+	if (list_empty(&fr_pool->all_list))
 		return;
 	iser_info("freeing conn %p fr pool\n", ib_conn);
-	list_for_each_entry_safe(desc, tmp, &fr_pool->list, list) {
+	list_for_each_entry_safe(desc, tmp, &fr_pool->all_list, all_list) {
-		list_del(&desc->list);
+		list_del(&desc->all_list);
 		iser_free_reg_res(&desc->rsc);
 		if (desc->pi_ctx)
 			iser_free_pi_ctx(desc->pi_ctx);

include/rdma/ib_verbs.h+17−13

 };
 struct ib_device {
+	/* Do not access @dma_device directly from ULP nor from HW drivers. */
+	struct device                *dma_device;
 	char                          name[IB_DEVICE_NAME_MAX];
 	struct list_head              event_handler_list;
  */
 static inline int ib_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
 {
-	return dma_mapping_error(&dev->dev, dma_addr);
+	return dma_mapping_error(dev->dma_device, dma_addr);
 }
 /**
 				    void *cpu_addr, size_t size,
 				    enum dma_data_direction direction)
 {
-	return dma_map_single(&dev->dev, cpu_addr, size, direction);
+	return dma_map_single(dev->dma_device, cpu_addr, size, direction);
 }
 /**
 				       u64 addr, size_t size,
 				       enum dma_data_direction direction)
 {
-	dma_unmap_single(&dev->dev, addr, size, direction);
+	dma_unmap_single(dev->dma_device, addr, size, direction);
 }
 /**
 				  size_t size,
 					 enum dma_data_direction direction)
 {
-	return dma_map_page(&dev->dev, page, offset, size, direction);
+	return dma_map_page(dev->dma_device, page, offset, size, direction);
 }
 /**
 				     u64 addr, size_t size,
 				     enum dma_data_direction direction)
 {
-	dma_unmap_page(&dev->dev, addr, size, direction);
+	dma_unmap_page(dev->dma_device, addr, size, direction);
 }
 /**
 				struct scatterlist *sg, int nents,
 				enum dma_data_direction direction)
 {
-	return dma_map_sg(&dev->dev, sg, nents, direction);
+	return dma_map_sg(dev->dma_device, sg, nents, direction);
 }
 /**
 				   struct scatterlist *sg, int nents,
 				   enum dma_data_direction direction)
 {
-	dma_unmap_sg(&dev->dev, sg, nents, direction);
+	dma_unmap_sg(dev->dma_device, sg, nents, direction);
 }
 static inline int ib_dma_map_sg_attrs(struct ib_device *dev,
 				      enum dma_data_direction direction,
 				      unsigned long dma_attrs)
 {
-	return dma_map_sg_attrs(&dev->dev, sg, nents, direction, dma_attrs);
+	return dma_map_sg_attrs(dev->dma_device, sg, nents, direction,
+				dma_attrs);
 }
 static inline void ib_dma_unmap_sg_attrs(struct ib_device *dev,
 					 enum dma_data_direction direction,
 					 unsigned long dma_attrs)
 {
-	dma_unmap_sg_attrs(&dev->dev, sg, nents, direction, dma_attrs);
+	dma_unmap_sg_attrs(dev->dma_device, sg, nents, direction, dma_attrs);
 }
 /**
  * ib_sg_dma_address - Return the DMA address from a scatter/gather entry
 					      size_t size,
 					      enum dma_data_direction dir)
 {
-	dma_sync_single_for_cpu(&dev->dev, addr, size, dir);
+	dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
 }
 /**
 						 size_t size,
 						 enum dma_data_direction dir)
 {
-	dma_sync_single_for_device(&dev->dev, addr, size, dir);
+	dma_sync_single_for_device(dev->dma_device, addr, size, dir);
 }
 /**
 					   dma_addr_t *dma_handle,
 					   gfp_t flag)
 {
-	return dma_alloc_coherent(&dev->dev, size, dma_handle, flag);
+	return dma_alloc_coherent(dev->dma_device, size, dma_handle, flag);
 }
 /**
 					size_t size, void *cpu_addr,
 					dma_addr_t dma_handle)
 {
-	dma_free_coherent(&dev->dev, size, cpu_addr, dma_handle);
+	dma_free_coherent(dev->dma_device, size, cpu_addr, dma_handle);
 }
 /**

include/uapi/rdma/mlx5-abi.h+2−1

 #define MLX5_ABI_USER_H
 #include <linux/types.h>
+#include <linux/if_ether.h>	/* For ETH_ALEN. */
 enum {
 	MLX5_QP_FLAG_SIGNATURE		= 1 << 0,
 };
 enum mlx5_lib_caps {
-	MLX5_LIB_CAP_4K_UAR	= (u64)1 << 0,
+	MLX5_LIB_CAP_4K_UAR	= (__u64)1 << 0,
 };
 struct mlx5_ib_alloc_ucontext_req_v2 {