* [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
2023-11-06 6:15 [PATCH v2 0/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2) Vivek Kasireddy
@ 2023-11-06 6:15 ` Vivek Kasireddy
2023-11-06 17:48 ` Jason Gunthorpe
` (3 more replies)
2023-11-06 6:15 ` [PATCH v2 2/3] udmabuf: Pin the pages using pin_user_pages_fd() API (v2) Vivek Kasireddy
2023-11-06 6:15 ` [PATCH v2 3/3] selftests/dma-buf/udmabuf: Add tests to verify data after page migration Vivek Kasireddy
2 siblings, 4 replies; 10+ messages in thread
From: Vivek Kasireddy @ 2023-11-06 6:15 UTC (permalink / raw)
To: dri-devel, linux-mm
Cc: Vivek Kasireddy, David Hildenbrand, Daniel Vetter, Mike Kravetz,
Hugh Dickins, Peter Xu, Gerd Hoffmann, Dongwon Kim, Junxiao Chang,
Jason Gunthorpe
For drivers that would like to longterm-pin the pages associated
with a file, the pin_user_pages_fd() API provides an option to
not only pin the pages via FOLL_PIN but also to check and migrate
them if they reside in movable zone or CMA block. This API
currently works with files that belong to either shmem or hugetlbfs.
Files belonging to other filesystems are rejected for now.
The pages need to be located first before pinning them via FOLL_PIN.
If they are found in the page cache, they can be immediately pinned.
Otherwise, they need to be allocated using the filesystem specific
APIs and then pinned.
v2:
- Drop gup_flags and improve comments and commit message (David)
- Allocate a page if we cannot find in page cache for the hugetlbfs
case as well (David)
- Don't unpin pages if there is a migration related failure (David)
- Drop the unnecessary nr_pages <= 0 check (Jason)
- Have the caller of the API pass in file * instead of fd (Jason)
Cc: David Hildenbrand <david@redhat.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Peter Xu <peterx@redhat.com>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Dongwon Kim <dongwon.kim@intel.com>
Cc: Junxiao Chang <junxiao.chang@intel.com>
Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
---
include/linux/mm.h | 2 +
mm/gup.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 101 insertions(+)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index bf5d0b1b16f4..f6cc17b14653 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2457,6 +2457,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
struct page **pages, unsigned int gup_flags);
long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
struct page **pages, unsigned int gup_flags);
+long pin_user_pages_fd(struct file *file, pgoff_t start,
+ unsigned long nr_pages, struct page **pages);
int get_user_pages_fast(unsigned long start, int nr_pages,
unsigned int gup_flags, struct page **pages);
diff --git a/mm/gup.c b/mm/gup.c
index 2f8a2d89fde1..d30b9dfebbb6 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -3400,3 +3400,102 @@ long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
&locked, gup_flags);
}
EXPORT_SYMBOL(pin_user_pages_unlocked);
+
+static struct page *alloc_file_page(struct file *file, pgoff_t idx)
+{
+ struct page *page = ERR_PTR(-ENOMEM);
+ struct folio *folio;
+ int err;
+
+ if (shmem_file(file))
+ return shmem_read_mapping_page(file->f_mapping, idx);
+
+ folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
+ NUMA_NO_NODE,
+ NULL,
+ GFP_USER);
+ if (folio && folio_try_get(folio)) {
+ page = &folio->page;
+ err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
+ if (err) {
+ folio_put(folio);
+ free_huge_folio(folio);
+ page = ERR_PTR(err);
+ }
+ }
+
+ return page;
+}
+
+/**
+ * pin_user_pages_fd() - pin user pages associated with a file
+ * @file: the file whose pages are to be pinned
+ * @start: starting file offset
+ * @nr_pages: number of pages from start to pin
+ * @pages: array that receives pointers to the pages pinned.
+ * Should be at-least nr_pages long.
+ *
+ * Attempt to pin pages associated with a file that belongs to either shmem
+ * or hugetlbfs. The pages are either found in the page cache or allocated
+ * if necessary. Once the pages are located, they are all pinned via FOLL_PIN.
+ * And, these pinned pages need to be released using unpin_user_pages() or
+ * unpin_user_page().
+ *
+ * Returns number of pages pinned. This would be equal to the number of
+ * pages requested. If no pages were pinned, it returns -errno.
+ */
+long pin_user_pages_fd(struct file *file, pgoff_t start,
+ unsigned long nr_pages, struct page **pages)
+{
+ struct page *page;
+ unsigned int flags, i;
+ long ret;
+
+ if (start < 0)
+ return -EINVAL;
+
+ if (!file)
+ return -EINVAL;
+
+ if (!shmem_file(file) && !is_file_hugepages(file))
+ return -EINVAL;
+
+ flags = memalloc_pin_save();
+ do {
+ for (i = 0; i < nr_pages; i++) {
+ /*
+ * In most cases, we should be able to find the page
+ * in the page cache. If we cannot find it, we try to
+ * allocate one and add it to the page cache.
+ */
+ page = find_get_page_flags(file->f_mapping,
+ start + i,
+ FGP_ACCESSED);
+ if (!page) {
+ page = alloc_file_page(file, start + i);
+ if (IS_ERR(page)) {
+ ret = PTR_ERR(page);
+ goto err;
+ }
+ }
+ ret = try_grab_page(page, FOLL_PIN);
+ if (unlikely(ret))
+ goto err;
+
+ pages[i] = page;
+ put_page(pages[i]);
+ }
+
+ ret = check_and_migrate_movable_pages(nr_pages, pages);
+ } while (ret == -EAGAIN);
+
+ memalloc_pin_restore(flags);
+ return ret ? ret : nr_pages;
+err:
+ while (i > 0 && pages[--i])
+ unpin_user_page(pages[i]);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(pin_user_pages_fd);
+
--
2.39.2
^ permalink raw reply related [flat|nested] 10+ messages in thread* Re: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
@ 2023-11-06 17:48 ` Jason Gunthorpe
2023-11-07 3:33 ` kernel test robot
` (2 subsequent siblings)
3 siblings, 0 replies; 10+ messages in thread
From: Jason Gunthorpe @ 2023-11-06 17:48 UTC (permalink / raw)
To: Vivek Kasireddy
Cc: dri-devel, linux-mm, David Hildenbrand, Daniel Vetter,
Mike Kravetz, Hugh Dickins, Peter Xu, Gerd Hoffmann, Dongwon Kim,
Junxiao Chang
On Sun, Nov 05, 2023 at 10:15:39PM -0800, Vivek Kasireddy wrote:
> For drivers that would like to longterm-pin the pages associated
> with a file, the pin_user_pages_fd() API provides an option to
> not only pin the pages via FOLL_PIN but also to check and migrate
> them if they reside in movable zone or CMA block. This API
> currently works with files that belong to either shmem or hugetlbfs.
> Files belonging to other filesystems are rejected for now.
>
> The pages need to be located first before pinning them via FOLL_PIN.
> If they are found in the page cache, they can be immediately pinned.
> Otherwise, they need to be allocated using the filesystem specific
> APIs and then pinned.
>
> v2:
> - Drop gup_flags and improve comments and commit message (David)
> - Allocate a page if we cannot find in page cache for the hugetlbfs
> case as well (David)
> - Don't unpin pages if there is a migration related failure (David)
> - Drop the unnecessary nr_pages <= 0 check (Jason)
> - Have the caller of the API pass in file * instead of fd (Jason)
>
> Cc: David Hildenbrand <david@redhat.com>
> Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
> Cc: Mike Kravetz <mike.kravetz@oracle.com>
> Cc: Hugh Dickins <hughd@google.com>
> Cc: Peter Xu <peterx@redhat.com>
> Cc: Gerd Hoffmann <kraxel@redhat.com>
> Cc: Dongwon Kim <dongwon.kim@intel.com>
> Cc: Junxiao Chang <junxiao.chang@intel.com>
> Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
> Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
> ---
> include/linux/mm.h | 2 +
> mm/gup.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 101 insertions(+)
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Jason
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
2023-11-06 17:48 ` Jason Gunthorpe
@ 2023-11-07 3:33 ` kernel test robot
2023-11-07 4:40 ` kernel test robot
2023-11-13 10:33 ` David Hildenbrand
3 siblings, 0 replies; 10+ messages in thread
From: kernel test robot @ 2023-11-07 3:33 UTC (permalink / raw)
To: Vivek Kasireddy, dri-devel, linux-mm
Cc: llvm, oe-kbuild-all, Vivek Kasireddy, David Hildenbrand,
Daniel Vetter, Mike Kravetz, Hugh Dickins, Peter Xu,
Gerd Hoffmann, Dongwon Kim, Junxiao Chang, Jason Gunthorpe
Hi Vivek,
kernel test robot noticed the following build errors:
[auto build test ERROR on akpm-mm/mm-everything]
url: https://github.com/intel-lab-lkp/linux/commits/Vivek-Kasireddy/mm-gup-Introduce-pin_user_pages_fd-for-pinning-shmem-hugetlbfs-file-pages-v2/20231106-141954
base: https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git mm-everything
patch link: https://lore.kernel.org/r/20231106061541.507116-2-vivek.kasireddy%40intel.com
patch subject: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
config: um-allyesconfig (https://download.01.org/0day-ci/archive/20231107/202311071110.ZGF6P4zc-lkp@intel.com/config)
compiler: clang version 14.0.6 (https://github.com/llvm/llvm-project.git f28c006a5895fc0e329fe15fead81e37457cb1d1)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231107/202311071110.ZGF6P4zc-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202311071110.ZGF6P4zc-lkp@intel.com/
All errors (new ones prefixed by >>):
In file included from mm/gup.c:9:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from arch/um/include/asm/hardirq.h:5:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:13:
In file included from arch/um/include/asm/io.h:24:
include/asm-generic/io.h:547:31: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __raw_readb(PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:560:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le16_to_cpu((__le16 __force)__raw_readw(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/little_endian.h:37:51: note: expanded from macro '__le16_to_cpu'
#define __le16_to_cpu(x) ((__force __u16)(__le16)(x))
^
In file included from mm/gup.c:9:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from arch/um/include/asm/hardirq.h:5:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:13:
In file included from arch/um/include/asm/io.h:24:
include/asm-generic/io.h:573:61: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
val = __le32_to_cpu((__le32 __force)__raw_readl(PCI_IOBASE + addr));
~~~~~~~~~~ ^
include/uapi/linux/byteorder/little_endian.h:35:51: note: expanded from macro '__le32_to_cpu'
#define __le32_to_cpu(x) ((__force __u32)(__le32)(x))
^
In file included from mm/gup.c:9:
In file included from include/linux/pagemap.h:11:
In file included from include/linux/highmem.h:12:
In file included from include/linux/hardirq.h:11:
In file included from arch/um/include/asm/hardirq.h:5:
In file included from include/asm-generic/hardirq.h:17:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:13:
In file included from arch/um/include/asm/io.h:24:
include/asm-generic/io.h:584:33: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writeb(value, PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:594:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writew((u16 __force)cpu_to_le16(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:604:59: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
__raw_writel((u32 __force)cpu_to_le32(value), PCI_IOBASE + addr);
~~~~~~~~~~ ^
include/asm-generic/io.h:692:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:700:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:708:20: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
readsl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:717:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesb(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:726:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesw(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
include/asm-generic/io.h:735:21: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
writesl(PCI_IOBASE + addr, buffer, count);
~~~~~~~~~~ ^
>> mm/gup.c:3419:9: error: implicit declaration of function 'hugetlb_add_to_page_cache' is invalid in C99 [-Werror,-Wimplicit-function-declaration]
err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
^
12 warnings and 1 error generated.
vim +/hugetlb_add_to_page_cache +3419 mm/gup.c
3403
3404 static struct page *alloc_file_page(struct file *file, pgoff_t idx)
3405 {
3406 struct page *page = ERR_PTR(-ENOMEM);
3407 struct folio *folio;
3408 int err;
3409
3410 if (shmem_file(file))
3411 return shmem_read_mapping_page(file->f_mapping, idx);
3412
3413 folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
3414 NUMA_NO_NODE,
3415 NULL,
3416 GFP_USER);
3417 if (folio && folio_try_get(folio)) {
3418 page = &folio->page;
> 3419 err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
3420 if (err) {
3421 folio_put(folio);
3422 free_huge_folio(folio);
3423 page = ERR_PTR(err);
3424 }
3425 }
3426
3427 return page;
3428 }
3429
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
2023-11-06 17:48 ` Jason Gunthorpe
2023-11-07 3:33 ` kernel test robot
@ 2023-11-07 4:40 ` kernel test robot
2023-11-13 10:33 ` David Hildenbrand
3 siblings, 0 replies; 10+ messages in thread
From: kernel test robot @ 2023-11-07 4:40 UTC (permalink / raw)
To: Vivek Kasireddy, dri-devel, linux-mm
Cc: llvm, oe-kbuild-all, Vivek Kasireddy, David Hildenbrand,
Daniel Vetter, Mike Kravetz, Hugh Dickins, Peter Xu,
Gerd Hoffmann, Dongwon Kim, Junxiao Chang, Jason Gunthorpe
Hi Vivek,
kernel test robot noticed the following build errors:
[auto build test ERROR on akpm-mm/mm-everything]
url: https://github.com/intel-lab-lkp/linux/commits/Vivek-Kasireddy/mm-gup-Introduce-pin_user_pages_fd-for-pinning-shmem-hugetlbfs-file-pages-v2/20231106-141954
base: https://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm.git mm-everything
patch link: https://lore.kernel.org/r/20231106061541.507116-2-vivek.kasireddy%40intel.com
patch subject: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
config: mips-maltaup_defconfig (https://download.01.org/0day-ci/archive/20231107/202311071223.ZeoRZg33-lkp@intel.com/config)
compiler: clang version 17.0.0 (https://github.com/llvm/llvm-project.git 4a5ac14ee968ff0ad5d2cc1ffa0299048db4c88a)
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20231107/202311071223.ZeoRZg33-lkp@intel.com/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@intel.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202311071223.ZeoRZg33-lkp@intel.com/
All errors (new ones prefixed by >>):
>> mm/gup.c:3419:9: error: call to undeclared function 'hugetlb_add_to_page_cache'; ISO C99 and later do not support implicit function declarations [-Wimplicit-function-declaration]
3419 | err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
| ^
1 error generated.
vim +/hugetlb_add_to_page_cache +3419 mm/gup.c
3403
3404 static struct page *alloc_file_page(struct file *file, pgoff_t idx)
3405 {
3406 struct page *page = ERR_PTR(-ENOMEM);
3407 struct folio *folio;
3408 int err;
3409
3410 if (shmem_file(file))
3411 return shmem_read_mapping_page(file->f_mapping, idx);
3412
3413 folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
3414 NUMA_NO_NODE,
3415 NULL,
3416 GFP_USER);
3417 if (folio && folio_try_get(folio)) {
3418 page = &folio->page;
> 3419 err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
3420 if (err) {
3421 folio_put(folio);
3422 free_huge_folio(folio);
3423 page = ERR_PTR(err);
3424 }
3425 }
3426
3427 return page;
3428 }
3429
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH v2 1/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2)
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
` (2 preceding siblings ...)
2023-11-07 4:40 ` kernel test robot
@ 2023-11-13 10:33 ` David Hildenbrand
2023-11-14 7:00 ` [PATCH] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v3) Vivek Kasireddy
3 siblings, 1 reply; 10+ messages in thread
From: David Hildenbrand @ 2023-11-13 10:33 UTC (permalink / raw)
To: Vivek Kasireddy, dri-devel, linux-mm
Cc: Daniel Vetter, Mike Kravetz, Hugh Dickins, Peter Xu,
Gerd Hoffmann, Dongwon Kim, Junxiao Chang, Jason Gunthorpe
On 06.11.23 07:15, Vivek Kasireddy wrote:
> For drivers that would like to longterm-pin the pages associated
> with a file, the pin_user_pages_fd() API provides an option to
> not only pin the pages via FOLL_PIN but also to check and migrate
> them if they reside in movable zone or CMA block. This API
> currently works with files that belong to either shmem or hugetlbfs.
> Files belonging to other filesystems are rejected for now.
>
> The pages need to be located first before pinning them via FOLL_PIN.
> If they are found in the page cache, they can be immediately pinned.
> Otherwise, they need to be allocated using the filesystem specific
> APIs and then pinned.
>
> v2:
> - Drop gup_flags and improve comments and commit message (David)
> - Allocate a page if we cannot find in page cache for the hugetlbfs
> case as well (David)
> - Don't unpin pages if there is a migration related failure (David)
> - Drop the unnecessary nr_pages <= 0 check (Jason)
> - Have the caller of the API pass in file * instead of fd (Jason)
>
> Cc: David Hildenbrand <david@redhat.com>
> Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
> Cc: Mike Kravetz <mike.kravetz@oracle.com>
> Cc: Hugh Dickins <hughd@google.com>
> Cc: Peter Xu <peterx@redhat.com>
> Cc: Gerd Hoffmann <kraxel@redhat.com>
> Cc: Dongwon Kim <dongwon.kim@intel.com>
> Cc: Junxiao Chang <junxiao.chang@intel.com>
> Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
> Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
> ---
> include/linux/mm.h | 2 +
> mm/gup.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 101 insertions(+)
>
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index bf5d0b1b16f4..f6cc17b14653 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -2457,6 +2457,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> struct page **pages, unsigned int gup_flags);
> long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> struct page **pages, unsigned int gup_flags);
> +long pin_user_pages_fd(struct file *file, pgoff_t start,
> + unsigned long nr_pages, struct page **pages);
>
> int get_user_pages_fast(unsigned long start, int nr_pages,
> unsigned int gup_flags, struct page **pages);
> diff --git a/mm/gup.c b/mm/gup.c
> index 2f8a2d89fde1..d30b9dfebbb6 100644
> --- a/mm/gup.c
> +++ b/mm/gup.c
> @@ -3400,3 +3400,102 @@ long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> &locked, gup_flags);
> }
> EXPORT_SYMBOL(pin_user_pages_unlocked);
> +
> +static struct page *alloc_file_page(struct file *file, pgoff_t idx)
> +{
> + struct page *page = ERR_PTR(-ENOMEM);
> + struct folio *folio;
> + int err;
> +
> + if (shmem_file(file))
> + return shmem_read_mapping_page(file->f_mapping, idx);
> +
As the build reports indicate, this might have to be fenced with
#ifdef CONFIG_HUGETLB_PAGE
> + folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
> + NUMA_NO_NODE,
> + NULL,
> + GFP_USER);
> + if (folio && folio_try_get(folio)) {
> + page = &folio->page;
> + err = hugetlb_add_to_page_cache(folio, file->f_mapping, idx);
> + if (err) {
> + folio_put(folio);
> + free_huge_folio(folio);
> + page = ERR_PTR(err);
> + }
> + }
> +
> + return page;
> +}
> +
> +/**
> + * pin_user_pages_fd() - pin user pages associated with a file
> + * @file: the file whose pages are to be pinned
> + * @start: starting file offset
> + * @nr_pages: number of pages from start to pin
> + * @pages: array that receives pointers to the pages pinned.
> + * Should be at-least nr_pages long.
> + *
> + * Attempt to pin pages associated with a file that belongs to either shmem
> + * or hugetlbfs. The pages are either found in the page cache or allocated
nit: s/hugetlbfs/hugetlb/
> + * if necessary. Once the pages are located, they are all pinned via FOLL_PIN.
> + * And, these pinned pages need to be released using unpin_user_pages() or
> + * unpin_user_page().
> + *
It might be reasonable to add that the behavior mimics FOLL_LONGTERM
semantics: the page may be held for an indefinite time period _often_
under userspace control.
> + * Returns number of pages pinned. This would be equal to the number of
> + * pages requested. If no pages were pinned, it returns -errno.
> + */
> +long pin_user_pages_fd(struct file *file, pgoff_t start,
> + unsigned long nr_pages, struct page **pages)
> +{
> + struct page *page;
> + unsigned int flags, i;
> + long ret;
> +
> + if (start < 0)
> + return -EINVAL;
> +
> + if (!file)
> + return -EINVAL;
> +
> + if (!shmem_file(file) && !is_file_hugepages(file))
> + return -EINVAL;
> +
> + flags = memalloc_pin_save();
> + do {
> + for (i = 0; i < nr_pages; i++) {
> + /*
> + * In most cases, we should be able to find the page
> + * in the page cache. If we cannot find it, we try to
> + * allocate one and add it to the page cache.
> + */
> + page = find_get_page_flags(file->f_mapping,
> + start + i,
> + FGP_ACCESSED);
> + if (!page) {
> + page = alloc_file_page(file, start + i);
> + if (IS_ERR(page)) {
> + ret = PTR_ERR(page);
> + goto err;
> + }
> + }
> + ret = try_grab_page(page, FOLL_PIN);
> + if (unlikely(ret))
> + goto err;
> +
> + pages[i] = page;
> + put_page(pages[i]);
> + }
> +
> + ret = check_and_migrate_movable_pages(nr_pages, pages);
> + } while (ret == -EAGAIN);
> +
> + memalloc_pin_restore(flags);
> + return ret ? ret : nr_pages;
> +err:
missing memalloc_pin_restore() ?
> + while (i > 0 && pages[--i])
> + unpin_user_page(pages[i]);
So if any pages[] would be 0, we would stop completely? Shouldn't this
be something like:
while (i-- > 0)
if (pages[i])
unpin_user_page(pages[i]);
--
Cheers,
David / dhildenb
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v3)
2023-11-13 10:33 ` David Hildenbrand
@ 2023-11-14 7:00 ` Vivek Kasireddy
2023-11-14 9:23 ` David Hildenbrand
0 siblings, 1 reply; 10+ messages in thread
From: Vivek Kasireddy @ 2023-11-14 7:00 UTC (permalink / raw)
To: dri-devel, linux-mm
Cc: Vivek Kasireddy, David Hildenbrand, Daniel Vetter, Mike Kravetz,
Hugh Dickins, Peter Xu, Gerd Hoffmann, Dongwon Kim, Junxiao Chang,
Jason Gunthorpe
For drivers that would like to longterm-pin the pages associated
with a file, the pin_user_pages_fd() API provides an option to
not only pin the pages via FOLL_PIN but also to check and migrate
them if they reside in movable zone or CMA block. This API
currently works with files that belong to either shmem or hugetlbfs.
Files belonging to other filesystems are rejected for now.
The pages need to be located first before pinning them via FOLL_PIN.
If they are found in the page cache, they can be immediately pinned.
Otherwise, they need to be allocated using the filesystem specific
APIs and then pinned.
v2:
- Drop gup_flags and improve comments and commit message (David)
- Allocate a page if we cannot find in page cache for the hugetlbfs
case as well (David)
- Don't unpin pages if there is a migration related failure (David)
- Drop the unnecessary nr_pages <= 0 check (Jason)
- Have the caller of the API pass in file * instead of fd (Jason)
v3: (David)
- Enclose the huge page allocation code with #ifdef CONFIG_HUGETLB_PAGE
(Build error reported by kernel test robot <lkp@intel.com>)
- Don't forget memalloc_pin_restore() on non-migration related errors
- Improve the readability of the cleanup code associated with
non-migration related errors
- Augment the comments by describing FOLL_LONGTERM like behavior
- Include the R-b tag from Jason
Cc: David Hildenbrand <david@redhat.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Peter Xu <peterx@redhat.com>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Dongwon Kim <dongwon.kim@intel.com>
Cc: Junxiao Chang <junxiao.chang@intel.com>
Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com> (v2)
Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
---
include/linux/mm.h | 2 +
mm/gup.c | 109 +++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 111 insertions(+)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 418d26608ece..1b675fa35059 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -2472,6 +2472,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
struct page **pages, unsigned int gup_flags);
long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
struct page **pages, unsigned int gup_flags);
+long pin_user_pages_fd(struct file *file, pgoff_t start,
+ unsigned long nr_pages, struct page **pages);
int get_user_pages_fast(unsigned long start, int nr_pages,
unsigned int gup_flags, struct page **pages);
diff --git a/mm/gup.c b/mm/gup.c
index 231711efa390..b3af967cdff1 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -3410,3 +3410,112 @@ long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
&locked, gup_flags);
}
EXPORT_SYMBOL(pin_user_pages_unlocked);
+
+static struct page *alloc_file_page(struct file *file, pgoff_t idx)
+{
+#ifdef CONFIG_HUGETLB_PAGE
+ struct page *page = ERR_PTR(-ENOMEM);
+ struct folio *folio;
+ int err;
+
+ if (is_file_hugepages(file)) {
+ folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
+ NUMA_NO_NODE,
+ NULL,
+ GFP_USER);
+ if (folio && folio_try_get(folio)) {
+ page = &folio->page;
+ err = hugetlb_add_to_page_cache(folio,
+ file->f_mapping,
+ idx);
+ if (err) {
+ folio_put(folio);
+ free_huge_folio(folio);
+ page = ERR_PTR(err);
+ }
+ }
+ return page;
+ }
+#endif
+ return shmem_read_mapping_page(file->f_mapping, idx);
+}
+
+/**
+ * pin_user_pages_fd() - pin user pages associated with a file
+ * @file: the file whose pages are to be pinned
+ * @start: starting file offset
+ * @nr_pages: number of pages from start to pin
+ * @pages: array that receives pointers to the pages pinned.
+ * Should be at-least nr_pages long.
+ *
+ * Attempt to pin pages associated with a file that belongs to either shmem
+ * or hugetlb. The pages are either found in the page cache or allocated if
+ * necessary. Once the pages are located, they are all pinned via FOLL_PIN.
+ * And, these pinned pages need to be released either using unpin_user_pages()
+ * or unpin_user_page().
+ *
+ * It must be noted that the pages may be pinned for an indefinite amount
+ * of time. And, in most cases, the duration of time they may stay pinned
+ * would be controlled by the userspace. This behavior is effectively the
+ * same as using FOLL_LONGTERM with other GUP APIs.
+ *
+ * Returns number of pages pinned. This would be equal to the number of
+ * pages requested. If no pages were pinned, it returns -errno.
+ */
+long pin_user_pages_fd(struct file *file, pgoff_t start,
+ unsigned long nr_pages, struct page **pages)
+{
+ struct page *page;
+ unsigned int flags, i;
+ long ret;
+
+ if (start < 0)
+ return -EINVAL;
+
+ if (!file)
+ return -EINVAL;
+
+ if (!shmem_file(file) && !is_file_hugepages(file))
+ return -EINVAL;
+
+ flags = memalloc_pin_save();
+ do {
+ for (i = 0; i < nr_pages; i++) {
+ /*
+ * In most cases, we should be able to find the page
+ * in the page cache. If we cannot find it, we try to
+ * allocate one and add it to the page cache.
+ */
+ page = find_get_page_flags(file->f_mapping,
+ start + i,
+ FGP_ACCESSED);
+ if (!page) {
+ page = alloc_file_page(file, start + i);
+ if (IS_ERR(page)) {
+ ret = PTR_ERR(page);
+ goto err;
+ }
+ }
+ ret = try_grab_page(page, FOLL_PIN);
+ if (unlikely(ret))
+ goto err;
+
+ pages[i] = page;
+ put_page(pages[i]);
+ }
+
+ ret = check_and_migrate_movable_pages(nr_pages, pages);
+ } while (ret == -EAGAIN);
+
+ memalloc_pin_restore(flags);
+ return ret ? ret : nr_pages;
+err:
+ memalloc_pin_restore(flags);
+ while (i-- > 0)
+ if (pages[i])
+ unpin_user_page(pages[i]);
+
+ return ret;
+}
+EXPORT_SYMBOL_GPL(pin_user_pages_fd);
+
--
2.39.2
^ permalink raw reply related [flat|nested] 10+ messages in thread* Re: [PATCH] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v3)
2023-11-14 7:00 ` [PATCH] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v3) Vivek Kasireddy
@ 2023-11-14 9:23 ` David Hildenbrand
0 siblings, 0 replies; 10+ messages in thread
From: David Hildenbrand @ 2023-11-14 9:23 UTC (permalink / raw)
To: Vivek Kasireddy, dri-devel, linux-mm
Cc: Daniel Vetter, Mike Kravetz, Hugh Dickins, Peter Xu,
Gerd Hoffmann, Dongwon Kim, Junxiao Chang, Jason Gunthorpe
On 14.11.23 08:00, Vivek Kasireddy wrote:
> For drivers that would like to longterm-pin the pages associated
> with a file, the pin_user_pages_fd() API provides an option to
> not only pin the pages via FOLL_PIN but also to check and migrate
> them if they reside in movable zone or CMA block. This API
> currently works with files that belong to either shmem or hugetlbfs.
> Files belonging to other filesystems are rejected for now.
>
> The pages need to be located first before pinning them via FOLL_PIN.
> If they are found in the page cache, they can be immediately pinned.
> Otherwise, they need to be allocated using the filesystem specific
> APIs and then pinned.
>
> v2:
> - Drop gup_flags and improve comments and commit message (David)
> - Allocate a page if we cannot find in page cache for the hugetlbfs
> case as well (David)
> - Don't unpin pages if there is a migration related failure (David)
> - Drop the unnecessary nr_pages <= 0 check (Jason)
> - Have the caller of the API pass in file * instead of fd (Jason)
>
> v3: (David)
> - Enclose the huge page allocation code with #ifdef CONFIG_HUGETLB_PAGE
> (Build error reported by kernel test robot <lkp@intel.com>)
> - Don't forget memalloc_pin_restore() on non-migration related errors
> - Improve the readability of the cleanup code associated with
> non-migration related errors
> - Augment the comments by describing FOLL_LONGTERM like behavior
> - Include the R-b tag from Jason
>
> Cc: David Hildenbrand <david@redhat.com>
> Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
> Cc: Mike Kravetz <mike.kravetz@oracle.com>
> Cc: Hugh Dickins <hughd@google.com>
> Cc: Peter Xu <peterx@redhat.com>
> Cc: Gerd Hoffmann <kraxel@redhat.com>
> Cc: Dongwon Kim <dongwon.kim@intel.com>
> Cc: Junxiao Chang <junxiao.chang@intel.com>
> Suggested-by: Jason Gunthorpe <jgg@nvidia.com>
> Reviewed-by: Jason Gunthorpe <jgg@nvidia.com> (v2)
> Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
> ---
> include/linux/mm.h | 2 +
> mm/gup.c | 109 +++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 111 insertions(+)
>
> diff --git a/include/linux/mm.h b/include/linux/mm.h
> index 418d26608ece..1b675fa35059 100644
> --- a/include/linux/mm.h
> +++ b/include/linux/mm.h
> @@ -2472,6 +2472,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> struct page **pages, unsigned int gup_flags);
> long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> struct page **pages, unsigned int gup_flags);
> +long pin_user_pages_fd(struct file *file, pgoff_t start,
> + unsigned long nr_pages, struct page **pages);
>
> int get_user_pages_fast(unsigned long start, int nr_pages,
> unsigned int gup_flags, struct page **pages);
> diff --git a/mm/gup.c b/mm/gup.c
> index 231711efa390..b3af967cdff1 100644
> --- a/mm/gup.c
> +++ b/mm/gup.c
> @@ -3410,3 +3410,112 @@ long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
> &locked, gup_flags);
> }
> EXPORT_SYMBOL(pin_user_pages_unlocked);
> +
> +static struct page *alloc_file_page(struct file *file, pgoff_t idx)
> +{
> +#ifdef CONFIG_HUGETLB_PAGE
> + struct page *page = ERR_PTR(-ENOMEM);
> + struct folio *folio;
> + int err;
> +
> + if (is_file_hugepages(file)) {
> + folio = alloc_hugetlb_folio_nodemask(hstate_file(file),
> + NUMA_NO_NODE,
> + NULL,
> + GFP_USER);
> + if (folio && folio_try_get(folio)) {
> + page = &folio->page;
> + err = hugetlb_add_to_page_cache(folio,
> + file->f_mapping,
> + idx);
> + if (err) {
> + folio_put(folio);
> + free_huge_folio(folio);
> + page = ERR_PTR(err);
> + }
> + }
> + return page;
You could avoid the "page" variable completely simply by using 3 return
statements.
LGTM, thanks
Reviewed-by: David Hildenbrand <david@redhat.com>
--
Cheers,
David / dhildenb
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH v2 2/3] udmabuf: Pin the pages using pin_user_pages_fd() API (v2)
2023-11-06 6:15 [PATCH v2 0/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2) Vivek Kasireddy
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
@ 2023-11-06 6:15 ` Vivek Kasireddy
2023-11-06 6:15 ` [PATCH v2 3/3] selftests/dma-buf/udmabuf: Add tests to verify data after page migration Vivek Kasireddy
2 siblings, 0 replies; 10+ messages in thread
From: Vivek Kasireddy @ 2023-11-06 6:15 UTC (permalink / raw)
To: dri-devel, linux-mm
Cc: Vivek Kasireddy, David Hildenbrand, Daniel Vetter, Mike Kravetz,
Hugh Dickins, Peter Xu, Jason Gunthorpe, Gerd Hoffmann,
Dongwon Kim, Junxiao Chang
Using pin_user_pages_fd() will ensure that the pages are pinned
correctly using FOLL_PIN. And, this also ensures that we don't
accidentally break features such as memory hotunplug as it would
not allow pinning pages in the movable zone.
This patch also adds back support for mapping hugetlbfs pages
by noting the subpage offsets within the huge pages and uses
this information while populating the scatterlist.
v2:
- Adjust to the change in signature of pin_user_pages_fd() by
passing in file * instead of fd.
Cc: David Hildenbrand <david@redhat.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Peter Xu <peterx@redhat.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Dongwon Kim <dongwon.kim@intel.com>
Cc: Junxiao Chang <junxiao.chang@intel.com>
Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
---
drivers/dma-buf/udmabuf.c | 81 +++++++++++++++++++++++++++++----------
1 file changed, 60 insertions(+), 21 deletions(-)
diff --git a/drivers/dma-buf/udmabuf.c b/drivers/dma-buf/udmabuf.c
index 820c993c8659..aa47af2b547f 100644
--- a/drivers/dma-buf/udmabuf.c
+++ b/drivers/dma-buf/udmabuf.c
@@ -10,6 +10,7 @@
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/shmem_fs.h>
+#include <linux/hugetlb.h>
#include <linux/slab.h>
#include <linux/udmabuf.h>
#include <linux/vmalloc.h>
@@ -28,6 +29,7 @@ struct udmabuf {
struct page **pages;
struct sg_table *sg;
struct miscdevice *device;
+ pgoff_t *subpgoff;
};
static vm_fault_t udmabuf_vm_fault(struct vm_fault *vmf)
@@ -90,23 +92,31 @@ static struct sg_table *get_sg_table(struct device *dev, struct dma_buf *buf,
{
struct udmabuf *ubuf = buf->priv;
struct sg_table *sg;
+ struct scatterlist *sgl;
+ pgoff_t offset;
+ unsigned long i = 0;
int ret;
sg = kzalloc(sizeof(*sg), GFP_KERNEL);
if (!sg)
return ERR_PTR(-ENOMEM);
- ret = sg_alloc_table_from_pages(sg, ubuf->pages, ubuf->pagecount,
- 0, ubuf->pagecount << PAGE_SHIFT,
- GFP_KERNEL);
+
+ ret = sg_alloc_table(sg, ubuf->pagecount, GFP_KERNEL);
if (ret < 0)
- goto err;
+ goto err_alloc;
+
+ for_each_sg(sg->sgl, sgl, ubuf->pagecount, i) {
+ offset = ubuf->subpgoff ? ubuf->subpgoff[i] : 0;
+ sg_set_page(sgl, ubuf->pages[i], PAGE_SIZE, offset);
+ }
ret = dma_map_sgtable(dev, sg, direction, 0);
if (ret < 0)
- goto err;
+ goto err_map;
return sg;
-err:
+err_map:
sg_free_table(sg);
+err_alloc:
kfree(sg);
return ERR_PTR(ret);
}
@@ -142,7 +152,9 @@ static void release_udmabuf(struct dma_buf *buf)
put_sg_table(dev, ubuf->sg, DMA_BIDIRECTIONAL);
for (pg = 0; pg < ubuf->pagecount; pg++)
- put_page(ubuf->pages[pg]);
+ unpin_user_page(ubuf->pages[pg]);
+
+ kfree(ubuf->subpgoff);
kfree(ubuf->pages);
kfree(ubuf);
}
@@ -202,12 +214,13 @@ static long udmabuf_create(struct miscdevice *device,
{
DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
struct file *memfd = NULL;
- struct address_space *mapping = NULL;
struct udmabuf *ubuf;
struct dma_buf *buf;
- pgoff_t pgoff, pgcnt, pgidx, pgbuf = 0, pglimit;
- struct page *page;
- int seals, ret = -EINVAL;
+ pgoff_t pgoff, pgcnt, pgbuf = 0, pglimit, nr_pages;
+ pgoff_t subpgoff, maxsubpgs;
+ struct hstate *hpstate;
+ long ret = -EINVAL;
+ int seals;
u32 i, flags;
ubuf = kzalloc(sizeof(*ubuf), GFP_KERNEL);
@@ -241,8 +254,7 @@ static long udmabuf_create(struct miscdevice *device,
memfd = fget(list[i].memfd);
if (!memfd)
goto err;
- mapping = memfd->f_mapping;
- if (!shmem_mapping(mapping))
+ if (!shmem_file(memfd) && !is_file_hugepages(memfd))
goto err;
seals = memfd_fcntl(memfd, F_GET_SEALS, 0);
if (seals == -EINVAL)
@@ -253,14 +265,40 @@ static long udmabuf_create(struct miscdevice *device,
goto err;
pgoff = list[i].offset >> PAGE_SHIFT;
pgcnt = list[i].size >> PAGE_SHIFT;
- for (pgidx = 0; pgidx < pgcnt; pgidx++) {
- page = shmem_read_mapping_page(mapping, pgoff + pgidx);
- if (IS_ERR(page)) {
- ret = PTR_ERR(page);
+ if (is_file_hugepages(memfd)) {
+ if (!ubuf->subpgoff) {
+ ubuf->subpgoff = kmalloc_array(ubuf->pagecount,
+ sizeof(*ubuf->subpgoff),
+ GFP_KERNEL);
+ if (!ubuf->subpgoff) {
+ ret = -ENOMEM;
+ goto err;
+ }
+ }
+ hpstate = hstate_file(memfd);
+ pgoff = list[i].offset >> huge_page_shift(hpstate);
+ subpgoff = (list[i].offset &
+ ~huge_page_mask(hpstate)) >> PAGE_SHIFT;
+ maxsubpgs = huge_page_size(hpstate) >> PAGE_SHIFT;
+ }
+
+ do {
+ nr_pages = shmem_file(memfd) ? pgcnt : 1;
+ ret = pin_user_pages_fd(memfd, pgoff, nr_pages,
+ ubuf->pages + pgbuf);
+ if (ret < 0)
goto err;
+
+ if (is_file_hugepages(memfd)) {
+ ubuf->subpgoff[pgbuf] = subpgoff << PAGE_SHIFT;
+ if (++subpgoff == maxsubpgs) {
+ subpgoff = 0;
+ pgoff++;
+ }
}
- ubuf->pages[pgbuf++] = page;
- }
+ pgbuf += nr_pages;
+ pgcnt -= nr_pages;
+ } while (pgcnt > 0);
fput(memfd);
memfd = NULL;
}
@@ -283,10 +321,11 @@ static long udmabuf_create(struct miscdevice *device,
return dma_buf_fd(buf, flags);
err:
- while (pgbuf > 0)
- put_page(ubuf->pages[--pgbuf]);
+ while (pgbuf > 0 && ubuf->pages[--pgbuf])
+ unpin_user_page(ubuf->pages[pgbuf]);
if (memfd)
fput(memfd);
+ kfree(ubuf->subpgoff);
kfree(ubuf->pages);
kfree(ubuf);
return ret;
--
2.39.2
^ permalink raw reply related [flat|nested] 10+ messages in thread* [PATCH v2 3/3] selftests/dma-buf/udmabuf: Add tests to verify data after page migration
2023-11-06 6:15 [PATCH v2 0/3] mm/gup: Introduce pin_user_pages_fd() for pinning shmem/hugetlbfs file pages (v2) Vivek Kasireddy
2023-11-06 6:15 ` [PATCH v2 1/3] " Vivek Kasireddy
2023-11-06 6:15 ` [PATCH v2 2/3] udmabuf: Pin the pages using pin_user_pages_fd() API (v2) Vivek Kasireddy
@ 2023-11-06 6:15 ` Vivek Kasireddy
2 siblings, 0 replies; 10+ messages in thread
From: Vivek Kasireddy @ 2023-11-06 6:15 UTC (permalink / raw)
To: dri-devel, linux-mm
Cc: Vivek Kasireddy, Shuah Khan, David Hildenbrand, Daniel Vetter,
Mike Kravetz, Hugh Dickins, Peter Xu, Jason Gunthorpe,
Gerd Hoffmann, Dongwon Kim, Junxiao Chang
Since the memfd pages associated with a udmabuf may be migrated
as part of udmabuf create, we need to verify the data coherency
after successful migration. The new tests added in this patch try
to do just that using 4k sized pages and also 2 MB sized huge
pages for the memfd.
Successful completion of the tests would mean that there is no
disconnect between the memfd pages and the ones associated with
a udmabuf. And, these tests can also be augmented in the future
to test newer udmabuf features (such as handling memfd hole punch).
Cc: Shuah Khan <shuah@kernel.org>
Cc: David Hildenbrand <david@redhat.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Peter Xu <peterx@redhat.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Dongwon Kim <dongwon.kim@intel.com>
Cc: Junxiao Chang <junxiao.chang@intel.com>
Based-on-patch-by: Mike Kravetz <mike.kravetz@oracle.com>
Signed-off-by: Vivek Kasireddy <vivek.kasireddy@intel.com>
---
.../selftests/drivers/dma-buf/udmabuf.c | 151 +++++++++++++++++-
1 file changed, 147 insertions(+), 4 deletions(-)
diff --git a/tools/testing/selftests/drivers/dma-buf/udmabuf.c b/tools/testing/selftests/drivers/dma-buf/udmabuf.c
index c812080e304e..d76c813fe652 100644
--- a/tools/testing/selftests/drivers/dma-buf/udmabuf.c
+++ b/tools/testing/selftests/drivers/dma-buf/udmabuf.c
@@ -9,26 +9,132 @@
#include <errno.h>
#include <fcntl.h>
#include <malloc.h>
+#include <stdbool.h>
#include <sys/ioctl.h>
#include <sys/syscall.h>
+#include <sys/mman.h>
#include <linux/memfd.h>
#include <linux/udmabuf.h>
#define TEST_PREFIX "drivers/dma-buf/udmabuf"
#define NUM_PAGES 4
+#define NUM_ENTRIES 4
+#define MEMFD_SIZE 1024 /* in pages */
-static int memfd_create(const char *name, unsigned int flags)
+static unsigned int page_size;
+
+static int create_memfd_with_seals(off64_t size, bool hpage)
+{
+ int memfd, ret;
+ unsigned int flags = MFD_ALLOW_SEALING;
+
+ if (hpage)
+ flags |= MFD_HUGETLB;
+
+ memfd = memfd_create("udmabuf-test", flags);
+ if (memfd < 0) {
+ printf("%s: [skip,no-memfd]\n", TEST_PREFIX);
+ exit(77);
+ }
+
+ ret = fcntl(memfd, F_ADD_SEALS, F_SEAL_SHRINK);
+ if (ret < 0) {
+ printf("%s: [skip,fcntl-add-seals]\n", TEST_PREFIX);
+ exit(77);
+ }
+
+ ret = ftruncate(memfd, size);
+ if (ret == -1) {
+ printf("%s: [FAIL,memfd-truncate]\n", TEST_PREFIX);
+ exit(1);
+ }
+
+ return memfd;
+}
+
+static int create_udmabuf_list(int devfd, int memfd, off64_t memfd_size)
+{
+ struct udmabuf_create_list *list;
+ int ubuf_fd, i;
+
+ list = malloc(sizeof(struct udmabuf_create_list) +
+ sizeof(struct udmabuf_create_item) * NUM_ENTRIES);
+ if (!list) {
+ printf("%s: [FAIL, udmabuf-malloc]\n", TEST_PREFIX);
+ exit(1);
+ }
+
+ for (i = 0; i < NUM_ENTRIES; i++) {
+ list->list[i].memfd = memfd;
+ list->list[i].offset = i * (memfd_size / NUM_ENTRIES);
+ list->list[i].size = getpagesize() * NUM_PAGES;
+ }
+
+ list->count = NUM_ENTRIES;
+ list->flags = UDMABUF_FLAGS_CLOEXEC;
+ ubuf_fd = ioctl(devfd, UDMABUF_CREATE_LIST, list);
+ free(list);
+ if (ubuf_fd < 0) {
+ printf("%s: [FAIL, udmabuf-create]\n", TEST_PREFIX);
+ exit(1);
+ }
+
+ return ubuf_fd;
+}
+
+static void write_to_memfd(void *addr, off64_t size, char chr)
+{
+ int i;
+
+ for (i = 0; i < size / page_size; i++) {
+ *((char *)addr + (i * page_size)) = chr;
+ }
+}
+
+static void *mmap_fd(int fd, off64_t size)
{
- return syscall(__NR_memfd_create, name, flags);
+ void *addr;
+
+ addr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
+ if (addr == MAP_FAILED) {
+ printf("%s: ubuf_fd mmap fail\n", TEST_PREFIX);
+ exit(1);
+ }
+
+ return addr;
+}
+
+static int compare_chunks(void *addr1, void *addr2, off64_t memfd_size)
+{
+ off64_t off;
+ int i = 0, j, k = 0, ret = 0;
+ char char1, char2;
+
+ while (i < NUM_ENTRIES) {
+ off = i * (memfd_size / NUM_ENTRIES);
+ for (j = 0; j < NUM_PAGES; j++, k++) {
+ char1 = *((char *)addr1 + off + (j * getpagesize()));
+ char2 = *((char *)addr2 + (k * getpagesize()));
+ if (char1 != char2) {
+ ret = -1;
+ goto err;
+ }
+ }
+ i++;
+ }
+err:
+ munmap(addr1, memfd_size);
+ munmap(addr2, NUM_ENTRIES * NUM_PAGES * getpagesize());
+ return ret;
}
int main(int argc, char *argv[])
{
struct udmabuf_create create;
int devfd, memfd, buf, ret;
- off_t size;
- void *mem;
+ off64_t size;
+ void *addr1, *addr2;
devfd = open("/dev/udmabuf", O_RDWR);
if (devfd < 0) {
@@ -90,6 +196,9 @@ int main(int argc, char *argv[])
}
/* should work */
+ page_size = getpagesize();
+ addr1 = mmap_fd(memfd, size);
+ write_to_memfd(addr1, size, 'a');
create.memfd = memfd;
create.offset = 0;
create.size = size;
@@ -98,6 +207,40 @@ int main(int argc, char *argv[])
printf("%s: [FAIL,test-4]\n", TEST_PREFIX);
exit(1);
}
+ munmap(addr1, size);
+ close(buf);
+ close(memfd);
+
+ /* should work (migration of 4k size pages)*/
+ size = MEMFD_SIZE * page_size;
+ memfd = create_memfd_with_seals(size, false);
+ addr1 = mmap_fd(memfd, size);
+ write_to_memfd(addr1, size, 'a');
+ buf = create_udmabuf_list(devfd, memfd, size);
+ addr2 = mmap_fd(buf, NUM_PAGES * NUM_ENTRIES * getpagesize());
+ write_to_memfd(addr1, size, 'b');
+ ret = compare_chunks(addr1, addr2, size);
+ if (ret < 0) {
+ printf("%s: [FAIL,test-5]\n", TEST_PREFIX);
+ exit(1);
+ }
+ close(buf);
+ close(memfd);
+
+ /* should work (migration of 2MB size huge pages)*/
+ page_size = getpagesize() * 512; /* 2 MB */
+ size = MEMFD_SIZE * page_size;
+ memfd = create_memfd_with_seals(size, true);
+ addr1 = mmap_fd(memfd, size);
+ write_to_memfd(addr1, size, 'a');
+ buf = create_udmabuf_list(devfd, memfd, size);
+ addr2 = mmap_fd(buf, NUM_PAGES * NUM_ENTRIES * getpagesize());
+ write_to_memfd(addr1, size, 'b');
+ ret = compare_chunks(addr1, addr2, size);
+ if (ret < 0) {
+ printf("%s: [FAIL,test-6]\n", TEST_PREFIX);
+ exit(1);
+ }
fprintf(stderr, "%s: ok\n", TEST_PREFIX);
close(buf);
--
2.39.2
^ permalink raw reply related [flat|nested] 10+ messages in thread