xref: /freebsd/sys/compat/linuxkpi/common/include/linux/scatterlist.h (revision 256eb8d5361143b7d436a195530e0eefe1450e6d)

/*-
 * Copyright (c) 2010 Isilon Systems, Inc.
 * Copyright (c) 2010 iX Systems, Inc.
 * Copyright (c) 2010 Panasas, Inc.
 * Copyright (c) 2013-2017 Mellanox Technologies, Ltd.
 * Copyright (c) 2015 Matthew Dillon <dillon@backplane.com>
 * Copyright (c) 2016 Matthew Macy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef	_LINUXKPI_LINUX_SCATTERLIST_H_
#define	_LINUXKPI_LINUX_SCATTERLIST_H_

#include <sys/types.h>
#include <sys/proc.h>
#include <sys/sched.h>
#include <sys/sf_buf.h>

#include <linux/err.h>
#include <linux/page.h>
#include <linux/slab.h>
#include <linux/mm.h>

struct bus_dmamap;
struct scatterlist {
	unsigned long page_link;
#define	SG_PAGE_LINK_CHAIN	0x1UL
#define	SG_PAGE_LINK_LAST	0x2UL
#define	SG_PAGE_LINK_MASK	0x3UL
	unsigned int offset;
	unsigned int length;
	dma_addr_t dma_address;
	struct bus_dmamap *dma_map;	/* FreeBSD specific */
};

CTASSERT((sizeof(struct scatterlist) & SG_PAGE_LINK_MASK) == 0);

struct sg_table {
	struct scatterlist *sgl;
	unsigned int nents;
	unsigned int orig_nents;
};

struct sg_page_iter {
	struct scatterlist *sg;
	unsigned int sg_pgoffset;
	unsigned int maxents;
	struct {
		unsigned int nents;
		int	pg_advance;
	} internal;
};

struct sg_dma_page_iter {
	struct sg_page_iter base;
};

#define	SCATTERLIST_MAX_SEGMENT	(-1U & ~(PAGE_SIZE - 1))

#define	SG_MAX_SINGLE_ALLOC	(PAGE_SIZE / sizeof(struct scatterlist))

#define	SG_MAGIC		0x87654321UL
#define	SG_CHAIN		SG_PAGE_LINK_CHAIN
#define	SG_END			SG_PAGE_LINK_LAST

#define	sg_is_chain(sg)		((sg)->page_link & SG_PAGE_LINK_CHAIN)
#define	sg_is_last(sg)		((sg)->page_link & SG_PAGE_LINK_LAST)
#define	sg_chain_ptr(sg)	\
	((struct scatterlist *) ((sg)->page_link & ~SG_PAGE_LINK_MASK))

#define	sg_dma_address(sg)	(sg)->dma_address
#define	sg_dma_len(sg)		(sg)->length

#define	for_each_sg_page(sgl, iter, nents, pgoffset)			\
	for (_sg_iter_init(sgl, iter, nents, pgoffset);			\
	     (iter)->sg; _sg_iter_next(iter))
#define	for_each_sg_dma_page(sgl, iter, nents, pgoffset) 		\
	for_each_sg_page(sgl, &(iter)->base, nents, pgoffset)

#define	for_each_sg(sglist, sg, sgmax, iter)				\
	for (iter = 0, sg = (sglist); iter < (sgmax); iter++, sg = sg_next(sg))

#define	for_each_sgtable_sg(sgt, sg, i) \
	for_each_sg((sgt)->sgl, sg, (sgt)->orig_nents, i)

#define	for_each_sgtable_page(sgt, iter, pgoffset) \
	for_each_sg_page((sgt)->sgl, iter, (sgt)->orig_nents, pgoffset)

#define	for_each_sgtable_dma_sg(sgt, sg, iter)				\
	for_each_sg((sgt)->sgl, sg, (sgt)->nents, iter)

#define	for_each_sgtable_dma_page(sgt, iter, pgoffset)			\
	for_each_sg_dma_page((sgt)->sgl, iter, (sgt)->nents, pgoffset)

typedef struct scatterlist *(sg_alloc_fn) (unsigned int, gfp_t);
typedef void (sg_free_fn) (struct scatterlist *, unsigned int);

static inline void
sg_assign_page(struct scatterlist *sg, struct page *page)
{
	unsigned long page_link = sg->page_link & SG_PAGE_LINK_MASK;

	sg->page_link = page_link | (unsigned long)page;
}

static inline void
sg_set_page(struct scatterlist *sg, struct page *page, unsigned int len,
    unsigned int offset)
{
	sg_assign_page(sg, page);
	sg->offset = offset;
	sg->length = len;
}

static inline struct page *
sg_page(struct scatterlist *sg)
{
	return ((struct page *)((sg)->page_link & ~SG_PAGE_LINK_MASK));
}

static inline void
sg_set_buf(struct scatterlist *sg, const void *buf, unsigned int buflen)
{
	sg_set_page(sg, virt_to_page(buf), buflen,
	    ((uintptr_t)buf) & (PAGE_SIZE - 1));
}

static inline struct scatterlist *
sg_next(struct scatterlist *sg)
{
	if (sg_is_last(sg))
		return (NULL);
	sg++;
	if (sg_is_chain(sg))
		sg = sg_chain_ptr(sg);
	return (sg);
}

static inline vm_paddr_t
sg_phys(struct scatterlist *sg)
{
	return (page_to_phys(sg_page(sg)) + sg->offset);
}

static inline void *
sg_virt(struct scatterlist *sg)
{

	return ((void *)((unsigned long)page_address(sg_page(sg)) + sg->offset));
}

static inline void
sg_chain(struct scatterlist *prv, unsigned int prv_nents,
    struct scatterlist *sgl)
{
	struct scatterlist *sg = &prv[prv_nents - 1];

	sg->offset = 0;
	sg->length = 0;
	sg->page_link = ((unsigned long)sgl |
	    SG_PAGE_LINK_CHAIN) & ~SG_PAGE_LINK_LAST;
}

static inline void
sg_mark_end(struct scatterlist *sg)
{
	sg->page_link |= SG_PAGE_LINK_LAST;
	sg->page_link &= ~SG_PAGE_LINK_CHAIN;
}

static inline void
sg_init_table(struct scatterlist *sg, unsigned int nents)
{
	bzero(sg, sizeof(*sg) * nents);
	sg_mark_end(&sg[nents - 1]);
}

static inline void
sg_init_one(struct scatterlist *sg, const void *buf, unsigned int buflen)
{
	sg_init_table(sg, 1);
	sg_set_buf(sg, buf, buflen);
}

static struct scatterlist *
sg_kmalloc(unsigned int nents, gfp_t gfp_mask)
{
	if (nents == SG_MAX_SINGLE_ALLOC) {
		return ((void *)__get_free_page(gfp_mask));
	} else
		return (kmalloc(nents * sizeof(struct scatterlist), gfp_mask));
}

static inline void
sg_kfree(struct scatterlist *sg, unsigned int nents)
{
	if (nents == SG_MAX_SINGLE_ALLOC) {
		free_page((unsigned long)sg);
	} else
		kfree(sg);
}

static inline void
__sg_free_table(struct sg_table *table, unsigned int max_ents,
    bool skip_first_chunk, sg_free_fn * free_fn)
{
	struct scatterlist *sgl, *next;

	if (unlikely(!table->sgl))
		return;

	sgl = table->sgl;
	while (table->orig_nents) {
		unsigned int alloc_size = table->orig_nents;
		unsigned int sg_size;

		if (alloc_size > max_ents) {
			next = sg_chain_ptr(&sgl[max_ents - 1]);
			alloc_size = max_ents;
			sg_size = alloc_size - 1;
		} else {
			sg_size = alloc_size;
			next = NULL;
		}

		table->orig_nents -= sg_size;
		if (skip_first_chunk)
			skip_first_chunk = 0;
		else
			free_fn(sgl, alloc_size);
		sgl = next;
	}

	table->sgl = NULL;
}

static inline void
sg_free_table(struct sg_table *table)
{
	__sg_free_table(table, SG_MAX_SINGLE_ALLOC, 0, sg_kfree);
}

static inline int
__sg_alloc_table(struct sg_table *table, unsigned int nents,
    unsigned int max_ents, struct scatterlist *first_chunk,
    gfp_t gfp_mask, sg_alloc_fn *alloc_fn)
{
	struct scatterlist *sg, *prv;
	unsigned int left;

	memset(table, 0, sizeof(*table));

	if (nents == 0)
		return (-EINVAL);
	left = nents;
	prv = NULL;
	do {
		unsigned int sg_size;
		unsigned int alloc_size = left;

		if (alloc_size > max_ents) {
			alloc_size = max_ents;
			sg_size = alloc_size - 1;
		} else
			sg_size = alloc_size;

		left -= sg_size;

		if (first_chunk) {
			sg = first_chunk;
			first_chunk = NULL;
		} else {
			sg = alloc_fn(alloc_size, gfp_mask);
		}
		if (unlikely(!sg)) {
			if (prv)
				table->nents = ++table->orig_nents;

			return (-ENOMEM);
		}
		sg_init_table(sg, alloc_size);
		table->nents = table->orig_nents += sg_size;

		if (prv)
			sg_chain(prv, max_ents, sg);
		else
			table->sgl = sg;

		if (!left)
			sg_mark_end(&sg[sg_size - 1]);

		prv = sg;
	} while (left);

	return (0);
}

static inline int
sg_alloc_table(struct sg_table *table, unsigned int nents, gfp_t gfp_mask)
{
	int ret;

	ret = __sg_alloc_table(table, nents, SG_MAX_SINGLE_ALLOC,
	    NULL, gfp_mask, sg_kmalloc);
	if (unlikely(ret))
		__sg_free_table(table, SG_MAX_SINGLE_ALLOC, 0, sg_kfree);

	return (ret);
}

#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
static inline struct scatterlist *
__sg_alloc_table_from_pages(struct sg_table *sgt,
    struct page **pages, unsigned int count,
    unsigned long off, unsigned long size,
    unsigned int max_segment,
    struct scatterlist *prv, unsigned int left_pages,
    gfp_t gfp_mask)
#else
static inline int
__sg_alloc_table_from_pages(struct sg_table *sgt,
    struct page **pages, unsigned int count,
    unsigned long off, unsigned long size,
    unsigned int max_segment, gfp_t gfp_mask)
#endif
{
	unsigned int i, segs, cur, len;
	int rc;
	struct scatterlist *s, *sg_iter;

#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
	if (prv != NULL) {
		panic(
		    "Support for prv != NULL not implemented in "
		    "__sg_alloc_table_from_pages()");
	}
#endif

	if (__predict_false(!max_segment || offset_in_page(max_segment)))
#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
		return (ERR_PTR(-EINVAL));
#else
		return (-EINVAL);
#endif

	len = 0;
	for (segs = i = 1; i < count; ++i) {
		len += PAGE_SIZE;
		if (len >= max_segment ||
		    page_to_pfn(pages[i]) != page_to_pfn(pages[i - 1]) + 1) {
			++segs;
			len = 0;
		}
	}
	if (__predict_false((rc = sg_alloc_table(sgt, segs, gfp_mask))))
#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
		return (ERR_PTR(rc));
#else
		return (rc);
#endif

	cur = 0;
	for_each_sg(sgt->sgl, sg_iter, sgt->orig_nents, i) {
		unsigned long seg_size;
		unsigned int j;

		/*
		 * We need to make sure that when we exit this loop "s" has the
		 * last sg in the chain so we can call sg_mark_end() on it.
		 * Only set this inside the loop since sg_iter will be iterated
		 * until it is NULL.
		 */
		s = sg_iter;

		len = 0;
		for (j = cur + 1; j < count; ++j) {
			len += PAGE_SIZE;
			if (len >= max_segment || page_to_pfn(pages[j]) !=
			    page_to_pfn(pages[j - 1]) + 1)
				break;
		}

		seg_size = ((j - cur) << PAGE_SHIFT) - off;
		sg_set_page(s, pages[cur], MIN(size, seg_size), off);
		size -= seg_size;
		off = 0;
		cur = j;
	}
	KASSERT(s != NULL, ("s is NULL after loop in __sg_alloc_table_from_pages()"));

#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
	if (left_pages == 0)
		sg_mark_end(s);

	return (s);
#else
	return (0);
#endif
}

static inline int
sg_alloc_table_from_pages(struct sg_table *sgt,
    struct page **pages, unsigned int count,
    unsigned long off, unsigned long size,
    gfp_t gfp_mask)
{

#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
	return (PTR_ERR_OR_ZERO(__sg_alloc_table_from_pages(sgt, pages, count, off, size,
	    SCATTERLIST_MAX_SEGMENT, NULL, 0, gfp_mask)));
#else
	return (__sg_alloc_table_from_pages(sgt, pages, count, off, size,
	    SCATTERLIST_MAX_SEGMENT, gfp_mask));
#endif
}

static inline int
sg_alloc_table_from_pages_segment(struct sg_table *sgt,
    struct page **pages, unsigned int count, unsigned int off,
    unsigned long size, unsigned int max_segment, gfp_t gfp_mask)
{
#if defined(LINUXKPI_VERSION) && LINUXKPI_VERSION >= 51300
	return (PTR_ERR_OR_ZERO(__sg_alloc_table_from_pages(sgt, pages, count, off, size,
	    max_segment, NULL, 0, gfp_mask)));
#else
	return (__sg_alloc_table_from_pages(sgt, pages, count, off, size,
	    max_segment, gfp_mask));
#endif
}

static inline int
sg_nents(struct scatterlist *sg)
{
	int nents;

	for (nents = 0; sg; sg = sg_next(sg))
		nents++;
	return (nents);
}

static inline void
__sg_page_iter_start(struct sg_page_iter *piter,
    struct scatterlist *sglist, unsigned int nents,
    unsigned long pgoffset)
{
	piter->internal.pg_advance = 0;
	piter->internal.nents = nents;

	piter->sg = sglist;
	piter->sg_pgoffset = pgoffset;
}

static inline void
_sg_iter_next(struct sg_page_iter *iter)
{
	struct scatterlist *sg;
	unsigned int pgcount;

	sg = iter->sg;
	pgcount = (sg->offset + sg->length + PAGE_SIZE - 1) >> PAGE_SHIFT;

	++iter->sg_pgoffset;
	while (iter->sg_pgoffset >= pgcount) {
		iter->sg_pgoffset -= pgcount;
		sg = sg_next(sg);
		--iter->maxents;
		if (sg == NULL || iter->maxents == 0)
			break;
		pgcount = (sg->offset + sg->length + PAGE_SIZE - 1) >> PAGE_SHIFT;
	}
	iter->sg = sg;
}

static inline int
sg_page_count(struct scatterlist *sg)
{
	return (PAGE_ALIGN(sg->offset + sg->length) >> PAGE_SHIFT);
}
#define	sg_dma_page_count(sg) \
	sg_page_count(sg)

static inline bool
__sg_page_iter_next(struct sg_page_iter *piter)
{
	unsigned int pgcount;

	if (piter->internal.nents == 0)
		return (0);
	if (piter->sg == NULL)
		return (0);

	piter->sg_pgoffset += piter->internal.pg_advance;
	piter->internal.pg_advance = 1;

	while (1) {
		pgcount = sg_page_count(piter->sg);
		if (likely(piter->sg_pgoffset < pgcount))
			break;
		piter->sg_pgoffset -= pgcount;
		piter->sg = sg_next(piter->sg);
		if (--piter->internal.nents == 0)
			return (0);
		if (piter->sg == NULL)
			return (0);
	}
	return (1);
}
#define	__sg_page_iter_dma_next(itr) \
	__sg_page_iter_next(&(itr)->base)

static inline void
_sg_iter_init(struct scatterlist *sgl, struct sg_page_iter *iter,
    unsigned int nents, unsigned long pgoffset)
{
	if (nents) {
		iter->sg = sgl;
		iter->sg_pgoffset = pgoffset - 1;
		iter->maxents = nents;
		_sg_iter_next(iter);
	} else {
		iter->sg = NULL;
		iter->sg_pgoffset = 0;
		iter->maxents = 0;
	}
}

/*
 * sg_page_iter_dma_address() is implemented as a macro because it
 * needs to accept two different and identical structure types. This
 * allows both old and new code to co-exist. The compile time assert
 * adds some safety, that the structure sizes match.
 */
#define	sg_page_iter_dma_address(spi) ({		\
	struct sg_page_iter *__spi = (void *)(spi);	\
	dma_addr_t __dma_address;			\
	CTASSERT(sizeof(*(spi)) == sizeof(*__spi));	\
	__dma_address = __spi->sg->dma_address +	\
	    (__spi->sg_pgoffset << PAGE_SHIFT);		\
	__dma_address;					\
})

static inline struct page *
sg_page_iter_page(struct sg_page_iter *piter)
{
	return (nth_page(sg_page(piter->sg), piter->sg_pgoffset));
}

static __inline size_t
sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
    const void *buf, size_t buflen, off_t skip)
{
	struct sg_page_iter piter;
	struct page *page;
	struct sf_buf *sf;
	size_t len, copied;
	char *p, *b;

	if (buflen == 0)
		return (0);

	b = __DECONST(char *, buf);
	copied = 0;
	sched_pin();
	for_each_sg_page(sgl, &piter, nents, 0) {

		/* Skip to the start. */
		if (piter.sg->length <= skip) {
			skip -= piter.sg->length;
			continue;
		}

		/* See how much to copy. */
		KASSERT(((piter.sg->length - skip) != 0 && (buflen != 0)),
		    ("%s: sg len %u - skip %ju || buflen %zu is 0\n",
		    __func__, piter.sg->length, (uintmax_t)skip, buflen));
		len = min(piter.sg->length - skip, buflen);

		page = sg_page_iter_page(&piter);
		sf = sf_buf_alloc(page, SFB_CPUPRIVATE | SFB_NOWAIT);
		if (sf == NULL)
			break;
		p = (char *)sf_buf_kva(sf) + piter.sg_pgoffset + skip;
		memcpy(p, b, len);
		sf_buf_free(sf);

		/* We copied so nothing more to skip. */
		skip = 0;
		copied += len;
		/* Either we exactly filled the page, or we are done. */
		buflen -= len;
		if (buflen == 0)
			break;
		b += len;
	}
	sched_unpin();

	return (copied);
}

static inline size_t
sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
    const void *buf, size_t buflen)
{
	return (sg_pcopy_from_buffer(sgl, nents, buf, buflen, 0));
}

static inline size_t
sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
    void *buf, size_t buflen, off_t offset)
{
	struct sg_page_iter iter;
	struct scatterlist *sg;
	struct page *page;
	struct sf_buf *sf;
	char *vaddr;
	size_t total = 0;
	size_t len;

	if (!PMAP_HAS_DMAP)
		sched_pin();
	for_each_sg_page(sgl, &iter, nents, 0) {
		sg = iter.sg;

		if (offset >= sg->length) {
			offset -= sg->length;
			continue;
		}
		len = ulmin(buflen, sg->length - offset);
		if (len == 0)
			break;

		page = sg_page_iter_page(&iter);
		if (!PMAP_HAS_DMAP) {
			sf = sf_buf_alloc(page, SFB_CPUPRIVATE | SFB_NOWAIT);
			if (sf == NULL)
				break;
			vaddr = (char *)sf_buf_kva(sf);
		} else
			vaddr = (char *)PHYS_TO_DMAP(page_to_phys(page));
		memcpy(buf, vaddr + sg->offset + offset, len);
		if (!PMAP_HAS_DMAP)
			sf_buf_free(sf);

		/* start at beginning of next page */
		offset = 0;

		/* advance buffer */
		buf = (char *)buf + len;
		buflen -= len;
		total += len;
	}
	if (!PMAP_HAS_DMAP)
		sched_unpin();
	return (total);
}

#endif					/* _LINUXKPI_LINUX_SCATTERLIST_H_ */