License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _LINUX_SCATTERLIST_H
|
|
|
|
#define _LINUX_SCATTERLIST_H
|
|
|
|
|
2011-11-24 01:12:59 +00:00
|
|
|
#include <linux/string.h>
|
2015-05-01 10:46:15 +00:00
|
|
|
#include <linux/types.h>
|
2011-11-24 01:12:59 +00:00
|
|
|
#include <linux/bug.h>
|
|
|
|
#include <linux/mm.h>
|
2007-10-22 17:57:20 +00:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
2015-05-01 10:46:15 +00:00
|
|
|
struct scatterlist {
|
|
|
|
unsigned long page_link;
|
|
|
|
unsigned int offset;
|
|
|
|
unsigned int length;
|
|
|
|
dma_addr_t dma_address;
|
|
|
|
#ifdef CONFIG_NEED_SG_DMA_LENGTH
|
|
|
|
unsigned int dma_length;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2017-08-03 09:13:12 +00:00
|
|
|
/*
|
|
|
|
* Since the above length field is an unsigned int, below we define the maximum
|
|
|
|
* length in bytes that can be stored in one scatterlist entry.
|
|
|
|
*/
|
|
|
|
#define SCATTERLIST_MAX_SEGMENT (UINT_MAX & PAGE_MASK)
|
|
|
|
|
2015-05-01 10:46:15 +00:00
|
|
|
/*
|
|
|
|
* These macros should be used after a dma_map_sg call has been done
|
|
|
|
* to get bus addresses of each of the SG entries and their lengths.
|
|
|
|
* You should only work with the number of sg entries dma_map_sg
|
|
|
|
* returns, or alternatively stop on the first sg_dma_len(sg) which
|
|
|
|
* is 0.
|
|
|
|
*/
|
|
|
|
#define sg_dma_address(sg) ((sg)->dma_address)
|
|
|
|
|
|
|
|
#ifdef CONFIG_NEED_SG_DMA_LENGTH
|
|
|
|
#define sg_dma_len(sg) ((sg)->dma_length)
|
|
|
|
#else
|
|
|
|
#define sg_dma_len(sg) ((sg)->length)
|
|
|
|
#endif
|
|
|
|
|
2007-11-30 08:16:50 +00:00
|
|
|
struct sg_table {
|
|
|
|
struct scatterlist *sgl; /* the list */
|
|
|
|
unsigned int nents; /* number of mapped entries */
|
|
|
|
unsigned int orig_nents; /* original size of list */
|
|
|
|
};
|
|
|
|
|
2007-10-22 17:57:20 +00:00
|
|
|
/*
|
|
|
|
* Notes on SG table design.
|
|
|
|
*
|
2015-05-01 10:46:15 +00:00
|
|
|
* We use the unsigned long page_link field in the scatterlist struct to place
|
|
|
|
* the page pointer AND encode information about the sg table as well. The two
|
|
|
|
* lower bits are reserved for this information.
|
2007-10-22 17:57:20 +00:00
|
|
|
*
|
|
|
|
* If bit 0 is set, then the page_link contains a pointer to the next sg
|
|
|
|
* table list. Otherwise the next entry is at sg + 1.
|
|
|
|
*
|
|
|
|
* If bit 1 is set, then this sg entry is the last element in a list.
|
|
|
|
*
|
|
|
|
* See sg_next().
|
|
|
|
*
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-02-15 03:33:56 +00:00
|
|
|
#define SG_CHAIN 0x01UL
|
|
|
|
#define SG_END 0x02UL
|
2007-10-22 18:01:06 +00:00
|
|
|
|
2007-11-27 08:30:39 +00:00
|
|
|
/*
|
|
|
|
* We overload the LSB of the page pointer to indicate whether it's
|
|
|
|
* a valid sg entry, or whether it points to the start of a new scatterlist.
|
|
|
|
* Those low bits are there for everyone! (thanks mason :-)
|
|
|
|
*/
|
2018-02-15 03:33:56 +00:00
|
|
|
#define sg_is_chain(sg) ((sg)->page_link & SG_CHAIN)
|
|
|
|
#define sg_is_last(sg) ((sg)->page_link & SG_END)
|
2007-11-27 08:30:39 +00:00
|
|
|
#define sg_chain_ptr(sg) \
|
2018-02-15 03:33:56 +00:00
|
|
|
((struct scatterlist *) ((sg)->page_link & ~(SG_CHAIN | SG_END)))
|
2007-11-27 08:30:39 +00:00
|
|
|
|
2007-10-22 15:07:37 +00:00
|
|
|
/**
|
2007-10-24 09:20:47 +00:00
|
|
|
* sg_assign_page - Assign a given page to an SG entry
|
|
|
|
* @sg: SG entry
|
|
|
|
* @page: The page
|
2007-10-22 15:07:37 +00:00
|
|
|
*
|
|
|
|
* Description:
|
2007-10-24 09:20:47 +00:00
|
|
|
* Assign page to sg entry. Also see sg_set_page(), the most commonly used
|
|
|
|
* variant.
|
2007-10-22 15:07:37 +00:00
|
|
|
*
|
|
|
|
**/
|
2007-10-24 09:20:47 +00:00
|
|
|
static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
|
2007-10-22 15:07:37 +00:00
|
|
|
{
|
2018-02-15 03:33:56 +00:00
|
|
|
unsigned long page_link = sg->page_link & (SG_CHAIN | SG_END);
|
2007-10-22 17:57:20 +00:00
|
|
|
|
2007-10-23 18:35:58 +00:00
|
|
|
/*
|
|
|
|
* In order for the low bit stealing approach to work, pages
|
|
|
|
* must be aligned at a 32-bit boundary as a minimum.
|
|
|
|
*/
|
2018-02-15 03:33:56 +00:00
|
|
|
BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
|
2007-10-22 18:01:06 +00:00
|
|
|
#ifdef CONFIG_DEBUG_SG
|
2007-11-27 08:30:39 +00:00
|
|
|
BUG_ON(sg_is_chain(sg));
|
2007-10-22 18:01:06 +00:00
|
|
|
#endif
|
2007-10-22 17:57:20 +00:00
|
|
|
sg->page_link = page_link | (unsigned long) page;
|
2007-10-22 15:07:37 +00:00
|
|
|
}
|
|
|
|
|
2007-10-24 09:20:47 +00:00
|
|
|
/**
|
|
|
|
* sg_set_page - Set sg entry to point at given page
|
|
|
|
* @sg: SG entry
|
|
|
|
* @page: The page
|
|
|
|
* @len: Length of data
|
|
|
|
* @offset: Offset into page
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Use this function to set an sg entry pointing at a page, never assign
|
|
|
|
* the page directly. We encode sg table information in the lower bits
|
|
|
|
* of the page pointer. See sg_page() for looking up the page belonging
|
|
|
|
* to an sg entry.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2007-11-27 08:30:39 +00:00
|
|
|
static inline struct page *sg_page(struct scatterlist *sg)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_SG
|
|
|
|
BUG_ON(sg_is_chain(sg));
|
|
|
|
#endif
|
2018-02-15 03:33:56 +00:00
|
|
|
return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END));
|
2007-11-27 08:30:39 +00:00
|
|
|
}
|
2007-10-22 15:07:37 +00:00
|
|
|
|
2007-10-22 17:57:20 +00:00
|
|
|
/**
|
|
|
|
* sg_set_buf - Set sg entry to point at given data
|
|
|
|
* @sg: SG entry
|
|
|
|
* @buf: Data
|
|
|
|
* @buflen: Data length
|
|
|
|
*
|
|
|
|
**/
|
2006-08-14 13:11:53 +00:00
|
|
|
static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
|
2005-09-17 04:41:40 +00:00
|
|
|
unsigned int buflen)
|
|
|
|
{
|
2013-05-30 07:19:35 +00:00
|
|
|
#ifdef CONFIG_DEBUG_SG
|
|
|
|
BUG_ON(!virt_addr_valid(buf));
|
|
|
|
#endif
|
2007-10-24 09:20:47 +00:00
|
|
|
sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-09 07:02:57 +00:00
|
|
|
/*
|
|
|
|
* Loop over each sg element, following the pointer to a new list if necessary
|
|
|
|
*/
|
|
|
|
#define for_each_sg(sglist, sg, nr, __i) \
|
|
|
|
for (__i = 0, sg = (sglist); __i < (nr); __i++, sg = sg_next(sg))
|
|
|
|
|
2020-05-13 13:32:09 +00:00
|
|
|
/*
|
|
|
|
* Loop over each sg element in the given sg_table object.
|
|
|
|
*/
|
|
|
|
#define for_each_sgtable_sg(sgt, sg, i) \
|
2020-06-30 08:16:02 +00:00
|
|
|
for_each_sg((sgt)->sgl, sg, (sgt)->orig_nents, i)
|
2020-05-13 13:32:09 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Loop over each sg element in the given *DMA mapped* sg_table object.
|
|
|
|
* Please use sg_dma_address(sg) and sg_dma_len(sg) to extract DMA addresses
|
|
|
|
* of the each element.
|
|
|
|
*/
|
|
|
|
#define for_each_sgtable_dma_sg(sgt, sg, i) \
|
2020-06-30 08:16:02 +00:00
|
|
|
for_each_sg((sgt)->sgl, sg, (sgt)->nents, i)
|
2020-05-13 13:32:09 +00:00
|
|
|
|
2007-07-16 19:17:16 +00:00
|
|
|
/**
|
|
|
|
* sg_chain - Chain two sglists together
|
|
|
|
* @prv: First scatterlist
|
|
|
|
* @prv_nents: Number of entries in prv
|
|
|
|
* @sgl: Second scatterlist
|
|
|
|
*
|
2007-10-22 17:57:20 +00:00
|
|
|
* Description:
|
|
|
|
* Links @prv@ and @sgl@ together, to form a longer scatterlist.
|
2007-07-16 19:17:16 +00:00
|
|
|
*
|
2007-10-22 17:57:20 +00:00
|
|
|
**/
|
2007-07-16 19:17:16 +00:00
|
|
|
static inline void sg_chain(struct scatterlist *prv, unsigned int prv_nents,
|
|
|
|
struct scatterlist *sgl)
|
|
|
|
{
|
2007-11-27 08:30:39 +00:00
|
|
|
/*
|
|
|
|
* offset and length are unused for chain entry. Clear them.
|
|
|
|
*/
|
2008-01-11 09:12:55 +00:00
|
|
|
prv[prv_nents - 1].offset = 0;
|
|
|
|
prv[prv_nents - 1].length = 0;
|
2007-11-27 08:30:39 +00:00
|
|
|
|
2007-10-26 07:32:16 +00:00
|
|
|
/*
|
|
|
|
* Set lowest bit to indicate a link pointer, and make sure to clear
|
|
|
|
* the termination bit if it happens to be set.
|
|
|
|
*/
|
2018-02-15 03:33:56 +00:00
|
|
|
prv[prv_nents - 1].page_link = ((unsigned long) sgl | SG_CHAIN)
|
|
|
|
& ~SG_END;
|
2007-07-16 19:17:16 +00:00
|
|
|
}
|
|
|
|
|
2007-10-22 15:07:37 +00:00
|
|
|
/**
|
|
|
|
* sg_mark_end - Mark the end of the scatterlist
|
2007-10-31 11:06:37 +00:00
|
|
|
* @sg: SG entryScatterlist
|
2007-10-22 15:07:37 +00:00
|
|
|
*
|
|
|
|
* Description:
|
2007-10-31 11:06:37 +00:00
|
|
|
* Marks the passed in sg entry as the termination point for the sg
|
|
|
|
* table. A call to sg_next() on this entry will return NULL.
|
2007-10-22 15:07:37 +00:00
|
|
|
*
|
|
|
|
**/
|
2007-10-31 11:06:37 +00:00
|
|
|
static inline void sg_mark_end(struct scatterlist *sg)
|
2007-10-22 15:07:37 +00:00
|
|
|
{
|
2007-10-31 11:06:37 +00:00
|
|
|
/*
|
|
|
|
* Set termination bit, clear potential chain bit
|
|
|
|
*/
|
2018-02-15 03:33:56 +00:00
|
|
|
sg->page_link |= SG_END;
|
|
|
|
sg->page_link &= ~SG_CHAIN;
|
2007-10-22 15:07:37 +00:00
|
|
|
}
|
|
|
|
|
2013-03-20 05:07:08 +00:00
|
|
|
/**
|
|
|
|
* sg_unmark_end - Undo setting the end of the scatterlist
|
|
|
|
* @sg: SG entryScatterlist
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* Removes the termination marker from the given entry of the scatterlist.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
static inline void sg_unmark_end(struct scatterlist *sg)
|
|
|
|
{
|
2018-02-15 03:33:56 +00:00
|
|
|
sg->page_link &= ~SG_END;
|
2013-03-20 05:07:08 +00:00
|
|
|
}
|
|
|
|
|
2007-10-22 15:07:37 +00:00
|
|
|
/**
|
|
|
|
* sg_phys - Return physical address of an sg entry
|
|
|
|
* @sg: SG entry
|
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This calls page_to_phys() on the page in this sg entry, and adds the
|
|
|
|
* sg offset. The caller must know that it is legal to call page_to_phys()
|
|
|
|
* on the sg page.
|
|
|
|
*
|
|
|
|
**/
|
2007-10-25 07:55:05 +00:00
|
|
|
static inline dma_addr_t sg_phys(struct scatterlist *sg)
|
2007-10-22 15:07:37 +00:00
|
|
|
{
|
|
|
|
return page_to_phys(sg_page(sg)) + sg->offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sg_virt - Return virtual address of an sg entry
|
2007-10-22 17:57:20 +00:00
|
|
|
* @sg: SG entry
|
2007-10-22 15:07:37 +00:00
|
|
|
*
|
|
|
|
* Description:
|
|
|
|
* This calls page_address() on the page in this sg entry, and adds the
|
|
|
|
* sg offset. The caller must know that the sg page has a valid virtual
|
|
|
|
* mapping.
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
static inline void *sg_virt(struct scatterlist *sg)
|
|
|
|
{
|
|
|
|
return page_address(sg_page(sg)) + sg->offset;
|
|
|
|
}
|
|
|
|
|
2018-03-30 00:20:59 +00:00
|
|
|
/**
|
|
|
|
* sg_init_marker - Initialize markers in sg table
|
|
|
|
* @sgl: The SG table
|
|
|
|
* @nents: Number of entries in table
|
|
|
|
*
|
|
|
|
**/
|
|
|
|
static inline void sg_init_marker(struct scatterlist *sgl,
|
|
|
|
unsigned int nents)
|
|
|
|
{
|
|
|
|
sg_mark_end(&sgl[nents - 1]);
|
|
|
|
}
|
|
|
|
|
2012-09-27 10:45:28 +00:00
|
|
|
int sg_nents(struct scatterlist *sg);
|
2015-06-01 16:15:25 +00:00
|
|
|
int sg_nents_for_len(struct scatterlist *sg, u64 len);
|
2007-11-30 08:16:50 +00:00
|
|
|
struct scatterlist *sg_next(struct scatterlist *);
|
|
|
|
struct scatterlist *sg_last(struct scatterlist *s, unsigned int);
|
|
|
|
void sg_init_table(struct scatterlist *, unsigned int);
|
|
|
|
void sg_init_one(struct scatterlist *, const void *, unsigned int);
|
lib: scatterlist: add sg splitting function
Sometimes a scatter-gather has to be split into several chunks, or sub
scatter lists. This happens for example if a scatter list will be
handled by multiple DMA channels, each one filling a part of it.
A concrete example comes with the media V4L2 API, where the scatter list
is allocated from userspace to hold an image, regardless of the
knowledge of how many DMAs will fill it :
- in a simple RGB565 case, one DMA will pump data from the camera ISP
to memory
- in the trickier YUV422 case, 3 DMAs will pump data from the camera
ISP pipes, one for pipe Y, one for pipe U and one for pipe V
For these cases, it is necessary to split the original scatter list into
multiple scatter lists, which is the purpose of this patch.
The guarantees that are required for this patch are :
- the intersection of spans of any couple of resulting scatter lists is
empty.
- the union of spans of all resulting scatter lists is a subrange of
the span of the original scatter list.
- streaming DMA API operations (mapping, unmapping) should not happen
both on both the resulting and the original scatter list. It's either
the first or the later ones.
- the caller is reponsible to call kfree() on the resulting
scatterlists.
Signed-off-by: Robert Jarzmik <robert.jarzmik@free.fr>
Signed-off-by: Jens Axboe <axboe@fb.com>
2015-08-08 08:44:10 +00:00
|
|
|
int sg_split(struct scatterlist *in, const int in_mapped_nents,
|
|
|
|
const off_t skip, const int nb_splits,
|
|
|
|
const size_t *split_sizes,
|
|
|
|
struct scatterlist **out, int *out_mapped_nents,
|
|
|
|
gfp_t gfp_mask);
|
2007-11-30 08:16:50 +00:00
|
|
|
|
|
|
|
typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t);
|
|
|
|
typedef void (sg_free_fn)(struct scatterlist *, unsigned int);
|
|
|
|
|
2019-04-28 07:39:30 +00:00
|
|
|
void __sg_free_table(struct sg_table *, unsigned int, unsigned int,
|
|
|
|
sg_free_fn *);
|
2007-11-30 08:16:50 +00:00
|
|
|
void sg_free_table(struct sg_table *);
|
2014-04-15 12:38:31 +00:00
|
|
|
int __sg_alloc_table(struct sg_table *, unsigned int, unsigned int,
|
2019-04-28 07:39:30 +00:00
|
|
|
struct scatterlist *, unsigned int, gfp_t, sg_alloc_fn *);
|
2007-11-30 08:16:50 +00:00
|
|
|
int sg_alloc_table(struct sg_table *, unsigned int, gfp_t);
|
2017-08-03 09:13:51 +00:00
|
|
|
int __sg_alloc_table_from_pages(struct sg_table *sgt, struct page **pages,
|
|
|
|
unsigned int n_pages, unsigned int offset,
|
|
|
|
unsigned long size, unsigned int max_segment,
|
|
|
|
gfp_t gfp_mask);
|
|
|
|
int sg_alloc_table_from_pages(struct sg_table *sgt, struct page **pages,
|
|
|
|
unsigned int n_pages, unsigned int offset,
|
|
|
|
unsigned long size, gfp_t gfp_mask);
|
2007-11-30 08:16:50 +00:00
|
|
|
|
2018-01-05 16:26:46 +00:00
|
|
|
#ifdef CONFIG_SGL_ALLOC
|
|
|
|
struct scatterlist *sgl_alloc_order(unsigned long long length,
|
|
|
|
unsigned int order, bool chainable,
|
|
|
|
gfp_t gfp, unsigned int *nent_p);
|
|
|
|
struct scatterlist *sgl_alloc(unsigned long long length, gfp_t gfp,
|
|
|
|
unsigned int *nent_p);
|
2018-01-19 19:00:54 +00:00
|
|
|
void sgl_free_n_order(struct scatterlist *sgl, int nents, int order);
|
2018-01-05 16:26:46 +00:00
|
|
|
void sgl_free_order(struct scatterlist *sgl, int order);
|
|
|
|
void sgl_free(struct scatterlist *sgl);
|
|
|
|
#endif /* CONFIG_SGL_ALLOC */
|
|
|
|
|
2015-06-30 21:58:57 +00:00
|
|
|
size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
|
|
|
|
size_t buflen, off_t skip, bool to_buffer);
|
|
|
|
|
2008-03-17 15:15:03 +00:00
|
|
|
size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
|
2015-06-30 21:58:54 +00:00
|
|
|
const void *buf, size_t buflen);
|
2008-03-17 15:15:03 +00:00
|
|
|
size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
|
|
|
|
void *buf, size_t buflen);
|
|
|
|
|
2013-07-08 23:01:54 +00:00
|
|
|
size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
|
2015-06-30 21:58:54 +00:00
|
|
|
const void *buf, size_t buflen, off_t skip);
|
2013-07-08 23:01:54 +00:00
|
|
|
size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
|
|
|
|
void *buf, size_t buflen, off_t skip);
|
2017-06-07 09:45:28 +00:00
|
|
|
size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents,
|
|
|
|
size_t buflen, off_t skip);
|
2013-07-08 23:01:54 +00:00
|
|
|
|
2007-11-30 08:16:50 +00:00
|
|
|
/*
|
|
|
|
* Maximum number of entries that will be allocated in one piece, if
|
|
|
|
* a list larger than this is required then chaining will be utilized.
|
|
|
|
*/
|
|
|
|
#define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist))
|
|
|
|
|
2016-04-04 21:48:11 +00:00
|
|
|
/*
|
|
|
|
* The maximum number of SG segments that we will put inside a
|
|
|
|
* scatterlist (unless chaining is used). Should ideally fit inside a
|
|
|
|
* single page, to avoid a higher order allocation. We could define this
|
|
|
|
* to SG_MAX_SINGLE_ALLOC to pack correctly at the highest order. The
|
|
|
|
* minimum value is 32
|
|
|
|
*/
|
|
|
|
#define SG_CHUNK_SIZE 128
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Like SG_CHUNK_SIZE, but for archs that have sg chaining. This limit
|
|
|
|
* is totally arbitrary, a setting of 2048 will get you at least 8mb ios.
|
|
|
|
*/
|
2018-11-09 08:51:00 +00:00
|
|
|
#ifdef CONFIG_ARCH_NO_SG_CHAIN
|
2016-04-04 21:48:11 +00:00
|
|
|
#define SG_MAX_SEGMENTS SG_CHUNK_SIZE
|
2018-11-09 08:51:00 +00:00
|
|
|
#else
|
|
|
|
#define SG_MAX_SEGMENTS 2048
|
2016-04-04 21:48:11 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_SG_POOL
|
2019-04-28 07:39:30 +00:00
|
|
|
void sg_free_table_chained(struct sg_table *table,
|
|
|
|
unsigned nents_first_chunk);
|
2016-04-04 21:48:11 +00:00
|
|
|
int sg_alloc_table_chained(struct sg_table *table, int nents,
|
2019-04-28 07:39:30 +00:00
|
|
|
struct scatterlist *first_chunk,
|
|
|
|
unsigned nents_first_chunk);
|
2016-04-04 21:48:11 +00:00
|
|
|
#endif
|
|
|
|
|
2013-02-28 01:02:56 +00:00
|
|
|
/*
|
|
|
|
* sg page iterator
|
|
|
|
*
|
2019-01-04 18:40:21 +00:00
|
|
|
* Iterates over sg entries page-by-page. On each successful iteration, you
|
2019-05-06 15:02:56 +00:00
|
|
|
* can call sg_page_iter_page(@piter) to get the current page.
|
|
|
|
* @piter->sg will point to the sg holding this page and @piter->sg_pgoffset to
|
|
|
|
* the page's page offset within the sg. The iteration will stop either when a
|
|
|
|
* maximum number of sg entries was reached or a terminating sg
|
|
|
|
* (sg_last(sg) == true) was reached.
|
2013-02-28 01:02:56 +00:00
|
|
|
*/
|
|
|
|
struct sg_page_iter {
|
|
|
|
struct scatterlist *sg; /* sg holding the page */
|
|
|
|
unsigned int sg_pgoffset; /* page offset within the sg */
|
|
|
|
|
|
|
|
/* these are internal states, keep away */
|
|
|
|
unsigned int __nents; /* remaining sg entries */
|
|
|
|
int __pg_advance; /* nr pages to advance at the
|
|
|
|
* next step */
|
|
|
|
};
|
|
|
|
|
2019-01-04 18:40:21 +00:00
|
|
|
/*
|
|
|
|
* sg page iterator for DMA addresses
|
|
|
|
*
|
|
|
|
* This is the same as sg_page_iter however you can call
|
|
|
|
* sg_page_iter_dma_address(@dma_iter) to get the page's DMA
|
|
|
|
* address. sg_page_iter_page() cannot be called on this iterator.
|
|
|
|
*/
|
|
|
|
struct sg_dma_page_iter {
|
|
|
|
struct sg_page_iter base;
|
|
|
|
};
|
|
|
|
|
2013-02-28 01:02:56 +00:00
|
|
|
bool __sg_page_iter_next(struct sg_page_iter *piter);
|
2019-01-04 18:40:21 +00:00
|
|
|
bool __sg_page_iter_dma_next(struct sg_dma_page_iter *dma_iter);
|
2013-02-28 01:02:56 +00:00
|
|
|
void __sg_page_iter_start(struct sg_page_iter *piter,
|
|
|
|
struct scatterlist *sglist, unsigned int nents,
|
|
|
|
unsigned long pgoffset);
|
2013-03-26 13:14:18 +00:00
|
|
|
/**
|
|
|
|
* sg_page_iter_page - get the current page held by the page iterator
|
|
|
|
* @piter: page iterator holding the page
|
|
|
|
*/
|
|
|
|
static inline struct page *sg_page_iter_page(struct sg_page_iter *piter)
|
|
|
|
{
|
|
|
|
return nth_page(sg_page(piter->sg), piter->sg_pgoffset);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* sg_page_iter_dma_address - get the dma address of the current page held by
|
|
|
|
* the page iterator.
|
2019-01-04 18:40:21 +00:00
|
|
|
* @dma_iter: page iterator holding the page
|
2013-03-26 13:14:18 +00:00
|
|
|
*/
|
2019-01-04 18:40:21 +00:00
|
|
|
static inline dma_addr_t
|
|
|
|
sg_page_iter_dma_address(struct sg_dma_page_iter *dma_iter)
|
2013-03-26 13:14:18 +00:00
|
|
|
{
|
2019-01-04 18:40:21 +00:00
|
|
|
return sg_dma_address(dma_iter->base.sg) +
|
|
|
|
(dma_iter->base.sg_pgoffset << PAGE_SHIFT);
|
2013-03-26 13:14:18 +00:00
|
|
|
}
|
2013-02-28 01:02:56 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* for_each_sg_page - iterate over the pages of the given sg list
|
|
|
|
* @sglist: sglist to iterate over
|
|
|
|
* @piter: page iterator to hold current page, sg, sg_pgoffset
|
|
|
|
* @nents: maximum number of sg entries to iterate over
|
2020-05-13 13:32:09 +00:00
|
|
|
* @pgoffset: starting page offset (in pages)
|
2019-01-04 18:40:21 +00:00
|
|
|
*
|
|
|
|
* Callers may use sg_page_iter_page() to get each page pointer.
|
2020-05-13 13:32:09 +00:00
|
|
|
* In each loop it operates on PAGE_SIZE unit.
|
2013-02-28 01:02:56 +00:00
|
|
|
*/
|
|
|
|
#define for_each_sg_page(sglist, piter, nents, pgoffset) \
|
|
|
|
for (__sg_page_iter_start((piter), (sglist), (nents), (pgoffset)); \
|
|
|
|
__sg_page_iter_next(piter);)
|
2008-07-19 14:03:35 +00:00
|
|
|
|
2019-01-04 18:40:21 +00:00
|
|
|
/**
|
|
|
|
* for_each_sg_dma_page - iterate over the pages of the given sg list
|
|
|
|
* @sglist: sglist to iterate over
|
2020-05-13 13:32:09 +00:00
|
|
|
* @dma_iter: DMA page iterator to hold current page
|
2019-01-04 18:40:21 +00:00
|
|
|
* @dma_nents: maximum number of sg entries to iterate over, this is the value
|
|
|
|
* returned from dma_map_sg
|
2020-05-13 13:32:09 +00:00
|
|
|
* @pgoffset: starting page offset (in pages)
|
2019-01-04 18:40:21 +00:00
|
|
|
*
|
|
|
|
* Callers may use sg_page_iter_dma_address() to get each page's DMA address.
|
2020-05-13 13:32:09 +00:00
|
|
|
* In each loop it operates on PAGE_SIZE unit.
|
2019-01-04 18:40:21 +00:00
|
|
|
*/
|
|
|
|
#define for_each_sg_dma_page(sglist, dma_iter, dma_nents, pgoffset) \
|
|
|
|
for (__sg_page_iter_start(&(dma_iter)->base, sglist, dma_nents, \
|
|
|
|
pgoffset); \
|
|
|
|
__sg_page_iter_dma_next(dma_iter);)
|
|
|
|
|
2020-05-13 13:32:09 +00:00
|
|
|
/**
|
|
|
|
* for_each_sgtable_page - iterate over all pages in the sg_table object
|
|
|
|
* @sgt: sg_table object to iterate over
|
|
|
|
* @piter: page iterator to hold current page
|
|
|
|
* @pgoffset: starting page offset (in pages)
|
|
|
|
*
|
|
|
|
* Iterates over the all memory pages in the buffer described by
|
|
|
|
* a scatterlist stored in the given sg_table object.
|
|
|
|
* See also for_each_sg_page(). In each loop it operates on PAGE_SIZE unit.
|
|
|
|
*/
|
|
|
|
#define for_each_sgtable_page(sgt, piter, pgoffset) \
|
2020-06-30 08:16:02 +00:00
|
|
|
for_each_sg_page((sgt)->sgl, piter, (sgt)->orig_nents, pgoffset)
|
2020-05-13 13:32:09 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* for_each_sgtable_dma_page - iterate over the DMA mapped sg_table object
|
|
|
|
* @sgt: sg_table object to iterate over
|
|
|
|
* @dma_iter: DMA page iterator to hold current page
|
|
|
|
* @pgoffset: starting page offset (in pages)
|
|
|
|
*
|
|
|
|
* Iterates over the all DMA mapped pages in the buffer described by
|
|
|
|
* a scatterlist stored in the given sg_table object.
|
|
|
|
* See also for_each_sg_dma_page(). In each loop it operates on PAGE_SIZE
|
|
|
|
* unit.
|
|
|
|
*/
|
|
|
|
#define for_each_sgtable_dma_page(sgt, dma_iter, pgoffset) \
|
2020-06-30 08:16:02 +00:00
|
|
|
for_each_sg_dma_page((sgt)->sgl, dma_iter, (sgt)->nents, pgoffset)
|
2020-05-13 13:32:09 +00:00
|
|
|
|
|
|
|
|
2008-07-19 14:03:35 +00:00
|
|
|
/*
|
|
|
|
* Mapping sg iterator
|
|
|
|
*
|
|
|
|
* Iterates over sg entries mapping page-by-page. On each successful
|
|
|
|
* iteration, @miter->page points to the mapped page and
|
|
|
|
* @miter->length bytes of data can be accessed at @miter->addr. As
|
|
|
|
* long as an interation is enclosed between start and stop, the user
|
|
|
|
* is free to choose control structure and when to stop.
|
|
|
|
*
|
|
|
|
* @miter->consumed is set to @miter->length on each iteration. It
|
|
|
|
* can be adjusted if the user can't consume all the bytes in one go.
|
|
|
|
* Also, a stopped iteration can be resumed by calling next on it.
|
|
|
|
* This is useful when iteration needs to release all resources and
|
|
|
|
* continue later (e.g. at the next interrupt).
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define SG_MITER_ATOMIC (1 << 0) /* use kmap_atomic */
|
2009-06-18 08:19:12 +00:00
|
|
|
#define SG_MITER_TO_SG (1 << 1) /* flush back to phys on unmap */
|
|
|
|
#define SG_MITER_FROM_SG (1 << 2) /* nop */
|
2008-07-19 14:03:35 +00:00
|
|
|
|
|
|
|
struct sg_mapping_iter {
|
|
|
|
/* the following three fields can be accessed directly */
|
|
|
|
struct page *page; /* currently mapped page */
|
|
|
|
void *addr; /* pointer to the mapped area */
|
|
|
|
size_t length; /* length of the mapped area */
|
|
|
|
size_t consumed; /* number of consumed bytes */
|
2013-02-28 01:02:57 +00:00
|
|
|
struct sg_page_iter piter; /* page iterator */
|
2008-07-19 14:03:35 +00:00
|
|
|
|
|
|
|
/* these are internal states, keep away */
|
2013-02-28 01:02:57 +00:00
|
|
|
unsigned int __offset; /* offset within page */
|
|
|
|
unsigned int __remaining; /* remaining bytes on page */
|
2008-07-19 14:03:35 +00:00
|
|
|
unsigned int __flags;
|
|
|
|
};
|
|
|
|
|
|
|
|
void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl,
|
|
|
|
unsigned int nents, unsigned int flags);
|
2013-11-26 04:43:37 +00:00
|
|
|
bool sg_miter_skip(struct sg_mapping_iter *miter, off_t offset);
|
2008-07-19 14:03:35 +00:00
|
|
|
bool sg_miter_next(struct sg_mapping_iter *miter);
|
|
|
|
void sg_miter_stop(struct sg_mapping_iter *miter);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _LINUX_SCATTERLIST_H */
|