[linux-block.git] / include / rdma / ib_umem.h

/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
/*
 * Copyright (c) 2007 Cisco Systems.  All rights reserved.
 * Copyright (c) 2020 Intel Corporation.  All rights reserved.
 */

#ifndef IB_UMEM_H
#define IB_UMEM_H

#include <linux/list.h>
#include <linux/scatterlist.h>
#include <linux/workqueue.h>
#include <rdma/ib_verbs.h>

struct ib_ucontext;
struct ib_umem_odp;
struct dma_buf_attach_ops;

struct ib_umem {
	struct ib_device       *ibdev;
	struct mm_struct       *owning_mm;
	u64 iova;
	size_t			length;
	unsigned long		address;
	u32 writable : 1;
	u32 is_odp : 1;
	u32 is_dmabuf : 1;
	struct sg_append_table sgt_append;
};

struct ib_umem_dmabuf {
	struct ib_umem umem;
	struct dma_buf_attachment *attach;
	struct sg_table *sgt;
	struct scatterlist *first_sg;
	struct scatterlist *last_sg;
	unsigned long first_sg_offset;
	unsigned long last_sg_trim;
	void *private;
	u8 pinned : 1;
};

static inline struct ib_umem_dmabuf *to_ib_umem_dmabuf(struct ib_umem *umem)
{
	return container_of(umem, struct ib_umem_dmabuf, umem);
}

/* Returns the offset of the umem start relative to the first page. */
static inline int ib_umem_offset(struct ib_umem *umem)
{
	return umem->address & ~PAGE_MASK;
}

static inline unsigned long ib_umem_dma_offset(struct ib_umem *umem,
					       unsigned long pgsz)
{
	return (sg_dma_address(umem->sgt_append.sgt.sgl) + ib_umem_offset(umem)) &
	       (pgsz - 1);
}

static inline size_t ib_umem_num_dma_blocks(struct ib_umem *umem,
					    unsigned long pgsz)
{
	return (size_t)((ALIGN(umem->iova + umem->length, pgsz) -
			 ALIGN_DOWN(umem->iova, pgsz))) /
	       pgsz;
}

static inline size_t ib_umem_num_pages(struct ib_umem *umem)
{
	return ib_umem_num_dma_blocks(umem, PAGE_SIZE);
}

static inline void __rdma_umem_block_iter_start(struct ib_block_iter *biter,
						struct ib_umem *umem,
						unsigned long pgsz)
{
	__rdma_block_iter_start(biter, umem->sgt_append.sgt.sgl,
				umem->sgt_append.sgt.nents, pgsz);
}

/**
 * rdma_umem_for_each_dma_block - iterate over contiguous DMA blocks of the umem
 * @umem: umem to iterate over
 * @pgsz: Page size to split the list into
 *
 * pgsz must be <= PAGE_SIZE or computed by ib_umem_find_best_pgsz(). The
 * returned DMA blocks will be aligned to pgsz and span the range:
 * ALIGN_DOWN(umem->address, pgsz) to ALIGN(umem->address + umem->length, pgsz)
 *
 * Performs exactly ib_umem_num_dma_blocks() iterations.
 */
#define rdma_umem_for_each_dma_block(umem, biter, pgsz)                        \
	for (__rdma_umem_block_iter_start(biter, umem, pgsz);                  \
	     __rdma_block_iter_next(biter);)

#ifdef CONFIG_INFINIBAND_USER_MEM

struct ib_umem *ib_umem_get(struct ib_device *device, unsigned long addr,
			    size_t size, int access);
void ib_umem_release(struct ib_umem *umem);
int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,
		      size_t length);
unsigned long ib_umem_find_best_pgsz(struct ib_umem *umem,
				     unsigned long pgsz_bitmap,
				     unsigned long virt);

/**
 * ib_umem_find_best_pgoff - Find best HW page size
 *
 * @umem: umem struct
 * @pgsz_bitmap bitmap of HW supported page sizes
 * @pgoff_bitmask: Mask of bits that can be represented with an offset
 *
 * This is very similar to ib_umem_find_best_pgsz() except instead of accepting
 * an IOVA it accepts a bitmask specifying what address bits can be represented
 * with a page offset.
 *
 * For instance if the HW has multiple page sizes, requires 64 byte alignemnt,
 * and can support aligned offsets up to 4032 then pgoff_bitmask would be
 * "111111000000".
 *
 * If the pgoff_bitmask requires either alignment in the low bit or an
 * unavailable page size for the high bits, this function returns 0.
 */
static inline unsigned long ib_umem_find_best_pgoff(struct ib_umem *umem,
						    unsigned long pgsz_bitmap,
						    u64 pgoff_bitmask)
{
	struct scatterlist *sg = umem->sgt_append.sgt.sgl;
	dma_addr_t dma_addr;

	dma_addr = sg_dma_address(sg) + (umem->address & ~PAGE_MASK);
	return ib_umem_find_best_pgsz(umem, pgsz_bitmap,
				      dma_addr & pgoff_bitmask);
}

struct ib_umem_dmabuf *ib_umem_dmabuf_get(struct ib_device *device,
					  unsigned long offset, size_t size,
					  int fd, int access,
					  const struct dma_buf_attach_ops *ops);
struct ib_umem_dmabuf *ib_umem_dmabuf_get_pinned(struct ib_device *device,
						 unsigned long offset,
						 size_t size, int fd,
						 int access);
int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf);
void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf);
void ib_umem_dmabuf_release(struct ib_umem_dmabuf *umem_dmabuf);

#else /* CONFIG_INFINIBAND_USER_MEM */

#include <linux/err.h>

static inline struct ib_umem *ib_umem_get(struct ib_device *device,
					  unsigned long addr, size_t size,
					  int access)
{
	return ERR_PTR(-EOPNOTSUPP);
}
static inline void ib_umem_release(struct ib_umem *umem) { }
static inline int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,
		      		    size_t length) {
	return -EOPNOTSUPP;
}
static inline unsigned long ib_umem_find_best_pgsz(struct ib_umem *umem,
						   unsigned long pgsz_bitmap,
						   unsigned long virt)
{
	return 0;
}
static inline unsigned long ib_umem_find_best_pgoff(struct ib_umem *umem,
						    unsigned long pgsz_bitmap,
						    u64 pgoff_bitmask)
{
	return 0;
}
static inline
struct ib_umem_dmabuf *ib_umem_dmabuf_get(struct ib_device *device,
					  unsigned long offset,
					  size_t size, int fd,
					  int access,
					  struct dma_buf_attach_ops *ops)
{
	return ERR_PTR(-EOPNOTSUPP);
}
static inline struct ib_umem_dmabuf *
ib_umem_dmabuf_get_pinned(struct ib_device *device, unsigned long offset,
			  size_t size, int fd, int access)
{
	return ERR_PTR(-EOPNOTSUPP);
}
static inline int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf)
{
	return -EOPNOTSUPP;
}
static inline void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf) { }
static inline void ib_umem_dmabuf_release(struct ib_umem_dmabuf *umem_dmabuf) { }

#endif /* CONFIG_INFINIBAND_USER_MEM */
#endif /* IB_UMEM_H */
Commit	Line	Data
6bf9d8f6	1	/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */
f7c6a7b5 RD	2	/*
f7c6a7b5 RD	3	* Copyright (c) 2007 Cisco Systems. All rights reserved.
368c0159	4	* Copyright (c) 2020 Intel Corporation. All rights reserved.
f7c6a7b5 RD	5	*/
	6
	7	#ifndef IB_UMEM_H
	8	#define IB_UMEM_H
	9
	10	#include <linux/list.h>
	11	#include <linux/scatterlist.h>
e8edc6e0	12	#include <linux/workqueue.h>
b0ea0fa5	13	#include <rdma/ib_verbs.h>
f7c6a7b5 RD	14
f7c6a7b5 RD	15	struct ib_ucontext;
8ada2c1c	16	struct ib_umem_odp;
368c0159	17	struct dma_buf_attach_ops;
f7c6a7b5 RD	18
f7c6a7b5 RD	19	struct ib_umem {
47f725ee	20	struct ib_device *ibdev;
d4b4dd1b	21	struct mm_struct *owning_mm;
a665aca8	22	u64 iova;
f7c6a7b5	23	size_t length;
406f9e5f	24	unsigned long address;
597ecc5a	25	u32 writable : 1;
597ecc5a	26	u32 is_odp : 1;
368c0159	27	u32 is_dmabuf : 1;
79fbd3e1	28	struct sg_append_table sgt_append;
f7c6a7b5 RD	29	};
f7c6a7b5 RD	30
368c0159 JX	31	struct ib_umem_dmabuf {
	32	struct ib_umem umem;
	33	struct dma_buf_attachment *attach;
	34	struct sg_table *sgt;
	35	struct scatterlist *first_sg;
	36	struct scatterlist *last_sg;
	37	unsigned long first_sg_offset;
	38	unsigned long last_sg_trim;
	39	void *private;
1e4df4a2	40	u8 pinned : 1;
368c0159 JX	41	};
	42
	43	static inline struct ib_umem_dmabuf to_ib_umem_dmabuf(struct ib_umem umem)
	44	{
	45	return container_of(umem, struct ib_umem_dmabuf, umem);
	46	}
	47
406f9e5f HE	48	/* Returns the offset of the umem start relative to the first page. */
	49	static inline int ib_umem_offset(struct ib_umem *umem)
	50	{
d2183c6f	51	return umem->address & ~PAGE_MASK;
406f9e5f HE	52	}
406f9e5f HE	53
b045db62 JG	54	static inline unsigned long ib_umem_dma_offset(struct ib_umem *umem,
	55	unsigned long pgsz)
	56	{
79fbd3e1	57	return (sg_dma_address(umem->sgt_append.sgt.sgl) + ib_umem_offset(umem)) &
b045db62 JG	58	(pgsz - 1);
	59	}
	60
a665aca8 JG	61	static inline size_t ib_umem_num_dma_blocks(struct ib_umem *umem,
	62	unsigned long pgsz)
	63	{
	64	return (size_t)((ALIGN(umem->iova + umem->length, pgsz) -
	65	ALIGN_DOWN(umem->iova, pgsz))) /
	66	pgsz;
	67	}
	68
406f9e5f HE	69	static inline size_t ib_umem_num_pages(struct ib_umem *umem)
406f9e5f HE	70	{
a665aca8	71	return ib_umem_num_dma_blocks(umem, PAGE_SIZE);
406f9e5f HE	72	}
406f9e5f HE	73
ebc24096 JG	74	static inline void __rdma_umem_block_iter_start(struct ib_block_iter *biter,
	75	struct ib_umem *umem,
	76	unsigned long pgsz)
	77	{
79fbd3e1 MG	78	__rdma_block_iter_start(biter, umem->sgt_append.sgt.sgl,
79fbd3e1 MG	79	umem->sgt_append.sgt.nents, pgsz);
ebc24096 JG	80	}
	81
	82	/**
	83	* rdma_umem_for_each_dma_block - iterate over contiguous DMA blocks of the umem
	84	* @umem: umem to iterate over
	85	* @pgsz: Page size to split the list into
	86	*
	87	* pgsz must be <= PAGE_SIZE or computed by ib_umem_find_best_pgsz(). The
	88	* returned DMA blocks will be aligned to pgsz and span the range:
	89	* ALIGN_DOWN(umem->address, pgsz) to ALIGN(umem->address + umem->length, pgsz)
a665aca8 JG	90	*
a665aca8 JG	91	* Performs exactly ib_umem_num_dma_blocks() iterations.
ebc24096 JG	92	*/
	93	#define rdma_umem_for_each_dma_block(umem, biter, pgsz) \
	94	for (__rdma_umem_block_iter_start(biter, umem, pgsz); \
	95	__rdma_block_iter_next(biter);)
	96
f7c6a7b5 RD	97	#ifdef CONFIG_INFINIBAND_USER_MEM
f7c6a7b5 RD	98
c320e527	99	struct ib_umem ib_umem_get(struct ib_device device, unsigned long addr,
72b894b0	100	size_t size, int access);
f7c6a7b5	101	void ib_umem_release(struct ib_umem *umem);
c5d76f13 HE	102	int ib_umem_copy_from(void dst, struct ib_umem umem, size_t offset,
c5d76f13 HE	103	size_t length);
4a353399 SS	104	unsigned long ib_umem_find_best_pgsz(struct ib_umem *umem,
	105	unsigned long pgsz_bitmap,
	106	unsigned long virt);
368c0159	107
b045db62 JG	108	/**
	109	* ib_umem_find_best_pgoff - Find best HW page size
	110	*
	111	* @umem: umem struct
	112	* @pgsz_bitmap bitmap of HW supported page sizes
	113	* @pgoff_bitmask: Mask of bits that can be represented with an offset
	114	*
	115	* This is very similar to ib_umem_find_best_pgsz() except instead of accepting
	116	* an IOVA it accepts a bitmask specifying what address bits can be represented
	117	* with a page offset.
	118	*
	119	* For instance if the HW has multiple page sizes, requires 64 byte alignemnt,
	120	* and can support aligned offsets up to 4032 then pgoff_bitmask would be
	121	* "111111000000".
	122	*
	123	* If the pgoff_bitmask requires either alignment in the low bit or an
	124	* unavailable page size for the high bits, this function returns 0.
	125	*/
	126	static inline unsigned long ib_umem_find_best_pgoff(struct ib_umem *umem,
	127	unsigned long pgsz_bitmap,
	128	u64 pgoff_bitmask)
	129	{
79fbd3e1	130	struct scatterlist *sg = umem->sgt_append.sgt.sgl;
b045db62 JG	131	dma_addr_t dma_addr;
	132
	133	dma_addr = sg_dma_address(sg) + (umem->address & ~PAGE_MASK);
	134	return ib_umem_find_best_pgsz(umem, pgsz_bitmap,
	135	dma_addr & pgoff_bitmask);
	136	}
f7c6a7b5	137
368c0159 JX	138	struct ib_umem_dmabuf ib_umem_dmabuf_get(struct ib_device device,
	139	unsigned long offset, size_t size,
	140	int fd, int access,
	141	const struct dma_buf_attach_ops *ops);
1e4df4a2 GP	142	struct ib_umem_dmabuf ib_umem_dmabuf_get_pinned(struct ib_device device,
	143	unsigned long offset,
	144	size_t size, int fd,
	145	int access);
368c0159 JX	146	int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf);
	147	void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf);
	148	void ib_umem_dmabuf_release(struct ib_umem_dmabuf *umem_dmabuf);
	149
f7c6a7b5 RD	150	#else /* CONFIG_INFINIBAND_USER_MEM */
	151
	152	#include <linux/err.h>
	153
c320e527	154	static inline struct ib_umem ib_umem_get(struct ib_device device,
f7c6a7b5	155	unsigned long addr, size_t size,
72b894b0	156	int access)
b0ea0fa5	157	{
368c0159	158	return ERR_PTR(-EOPNOTSUPP);
f7c6a7b5 RD	159	}
f7c6a7b5 RD	160	static inline void ib_umem_release(struct ib_umem *umem) { }
c1395a2a HE	161	static inline int ib_umem_copy_from(void dst, struct ib_umem umem, size_t offset,
c1395a2a HE	162	size_t length) {
368c0159	163	return -EOPNOTSUPP;
c1395a2a	164	}
61690d01 JG	165	static inline unsigned long ib_umem_find_best_pgsz(struct ib_umem *umem,
	166	unsigned long pgsz_bitmap,
	167	unsigned long virt)
	168	{
	169	return 0;
4a353399	170	}
b045db62 JG	171	static inline unsigned long ib_umem_find_best_pgoff(struct ib_umem *umem,
	172	unsigned long pgsz_bitmap,
	173	u64 pgoff_bitmask)
	174	{
	175	return 0;
	176	}
368c0159 JX	177	static inline
	178	struct ib_umem_dmabuf ib_umem_dmabuf_get(struct ib_device device,
	179	unsigned long offset,
	180	size_t size, int fd,
	181	int access,
	182	struct dma_buf_attach_ops *ops)
	183	{
	184	return ERR_PTR(-EOPNOTSUPP);
	185	}
1e4df4a2 GP	186	static inline struct ib_umem_dmabuf *
	187	ib_umem_dmabuf_get_pinned(struct ib_device *device, unsigned long offset,
	188	size_t size, int fd, int access)
	189	{
	190	return ERR_PTR(-EOPNOTSUPP);
	191	}
368c0159 JX	192	static inline int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf)
	193	{
	194	return -EOPNOTSUPP;
	195	}
	196	static inline void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf) { }
	197	static inline void ib_umem_dmabuf_release(struct ib_umem_dmabuf *umem_dmabuf) { }
4a353399	198
f7c6a7b5	199	#endif /* CONFIG_INFINIBAND_USER_MEM */
f7c6a7b5	200	#endif /* IB_UMEM_H */