Skip to contentSkip to conversation

introduce __put_user_pages(), convert a few call sites

PATCH In review [email protected] 5 participants 12 messages Jul 22, 2019 – Jul 23, 2019

Subsystems (10)
lore
Share & tools
lore
#0 lore raw

cover introduce __put_user_pages(), convert a few call sites

From: John Hubbard <[email protected]>

As discussed in [1] just now, this adds a more capable variation of put_user_pages() to the API set, and uses it to simplify both the main implementation, and (especially) the call sites.

Thanks to Christoph for the simplifying ideas, and Matthew for (again) recommending an enum in the API. Matthew, I seem to recall you asked for enums before this, so I'm sorry it took until now for me to add them. :)

The new __put_user_pages() takes an enum that handles the various combinations of needing to call set_page_dirty() or set_page_dirty_lock(), before calling put_user_page().

I'm using the same CC list as in [1], even though IB is no longer included in the series. That's everyone can see what the end result turns out to be.

Notes about the remaining patches to come:

There are about 50+ patches in my tree [2], and I'll be sending out the remaining ones in a few more groups:

* The block/bio related changes (Jerome mostly wrote those, but I've had to move stuff around extensively, and add a little code)

* mm/ changes

* other subsystem patches

* an RFC that shows the current state of the tracking patch set. That can only be applied after all call sites are converted, but it's good to get an early look at it.

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

[1] https://lore.kernel.org/r/[email protected]
[2] https://github.com/johnhubbard/linux/tree/gup_dma_core

John Hubbard (3):
mm/gup: introduce __put_user_pages() drivers/gpu/drm/via: convert put_page() to put_user_page*() net/xdp: convert put_page() to put_user_page*()

 drivers/gpu/drm/via/via_dmablit.c |  11 +--
 include/linux/mm.h                |  58 +++++++++++-
 mm/gup.c                          | 149 +++++++++++++++---------------
 net/xdp/xdp_umem.c                |   9 +-
 4 files changed, 135 insertions(+), 92 deletions(-)
Signature · 1 line
2.22.0
#1 lore raw

PATCH 1/3 mm/gup: introduce __put_user_pages()

From: John Hubbard <[email protected]>

Add a more capable variation of put_user_pages() to the API set, and call it from the simple ones.

The new __put_user_pages() takes an enum that handles the various combinations of needing to call set_page_dirty() or set_page_dirty_lock(), before calling put_user_page().

Cc Matthew Wilcox <[email protected]>
Cc Jan Kara <[email protected]>
Cc Christoph Hellwig <[email protected]>
---
 include/linux/mm.h |  58 ++++++++++++++++++-
 mm/gup.c           | 137 ++++++++++++++++++++++-----------------------
 2 files changed, 124 insertions(+), 71 deletions(-)
include/linux/mm.h +56 -2
index 0334ca97c584..7218585681b2 100644
@@ -1057,8 +1057,62 @@ static inline void put_user_page(struct page *page)
 	put_page(page);
 }
 
-void put_user_pages_dirty(struct page **pages, unsigned long npages);
-void put_user_pages_dirty_lock(struct page **pages, unsigned long npages);
+enum pup_flags_t {
+	PUP_FLAGS_CLEAN		= 0,
+	PUP_FLAGS_DIRTY		= 1,
+	PUP_FLAGS_LOCK		= 2,
+	PUP_FLAGS_DIRTY_LOCK	= 3,
+};
+
+void __put_user_pages(struct page **pages, unsigned long npages,
+		      enum pup_flags_t flags);
+
+/**
+ * put_user_pages_dirty() - release and dirty an array of gup-pinned pages
+ * @pages:  array of pages to be marked dirty and released.
+ * @npages: number of pages in the @pages array.
+ *
+ * "gup-pinned page" refers to a page that has had one of the get_user_pages()
+ * variants called on that page.
+ *
+ * For each page in the @pages array, make that page (or its head page, if a
+ * compound page) dirty, if it was previously listed as clean. Then, release
+ * the page using put_user_page().
+ *
+ * Please see the put_user_page() documentation for details.
+ *
+ * set_page_dirty(), which does not lock the page, is used here.
+ * Therefore, it is the caller's responsibility to ensure that this is
+ * safe. If not, then put_user_pages_dirty_lock() should be called instead.
+ *
+ */
+static inline void put_user_pages_dirty(struct page **pages,
+					unsigned long npages)
+{
+	__put_user_pages(pages, npages, PUP_FLAGS_DIRTY);
+}
+
+/**
+ * put_user_pages_dirty_lock() - release and dirty an array of gup-pinned pages
+ * @pages:  array of pages to be marked dirty and released.
+ * @npages: number of pages in the @pages array.
+ *
+ * For each page in the @pages array, make that page (or its head page, if a
+ * compound page) dirty, if it was previously listed as clean. Then, release
+ * the page using put_user_page().
+ *
+ * Please see the put_user_page() documentation for details.
+ *
+ * This is just like put_user_pages_dirty(), except that it invokes
+ * set_page_dirty_lock(), instead of set_page_dirty().
+ *
+ */
+static inline void put_user_pages_dirty_lock(struct page **pages,
+					     unsigned long npages)
+{
+	__put_user_pages(pages, npages, PUP_FLAGS_DIRTY_LOCK);
+}
+
 void put_user_pages(struct page **pages, unsigned long npages);
 
 #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
mm/gup.c +68 -69

155 lines not on this page · raw message

Signature · 1 line
2.22.0
#2 lore raw

Re: [PATCH 1/3] mm/gup: introduce __put_user_pages()

include/linux/mm.h static inline void put_user_page(struct page *page) · line 1065

Quoted 6 lines · On Mon, Jul 22, 2019 at 03:34:13PM -0700, [email protected] wrote:
include/linux/mm.h +6 -0
+enum pup_flags_t {
+	PUP_FLAGS_CLEAN		= 0,
+	PUP_FLAGS_DIRTY		= 1,
+	PUP_FLAGS_LOCK		= 2,
+	PUP_FLAGS_DIRTY_LOCK	= 3,
+};

Well, the enum defeats the ease of just being able to pass a boolean expression to the function, which would simplify a lot of the caller, so if we need to support the !locked version I'd rather see that as a separate helper.

But do we actually have callers where not using the _lock version is not a bug? set_page_dirty makes sense in the context of a file systems that have a reference to the inode the page hangs off, but that is (almost?) never the case for get_user_pages.

reviewer
#3 lore raw

Re: [PATCH 1/3] mm/gup: introduce __put_user_pages()

Quoted 13 lines · Christoph Hellwig

include/linux/mm.h static inline void put_user_page(struct page *page) · line 1065

Quoted 6 lines · On Mon, Jul 22, 2019 at 03:34:13PM -0700, [email protected] wrote:
include/linux/mm.h +6 -0
+enum pup_flags_t {
+	PUP_FLAGS_CLEAN		= 0,
+	PUP_FLAGS_DIRTY		= 1,
+	PUP_FLAGS_LOCK		= 2,
+	PUP_FLAGS_DIRTY_LOCK	= 3,
+};

Well, the enum defeats the ease of just being able to pass a boolean expression to the function, which would simplify a lot of the caller, so if we need to support the !locked version I'd rather see that as a separate helper.

Quoted 5 lines

But do we actually have callers where not using the _lock version is not a bug? set_page_dirty makes sense in the context of a file systems that have a reference to the inode the page hangs off, but that is (almost?) never the case for get_user_pages.

I'm seeing about 18 places where set_page_dirty() is used, in the call site conversions so far, and about 20 places where set_page_dirty_lock() is used. So without knowing how many of the former (if any) represent bugs, you can see why the proposal here supports both DIRTY and DIRTY_LOCK.

Anyway, yes, I could change it, based on your estimation that most of the set_page_dirty() calls really should be set_page_dirty_lock(). In that case, we would end up with approximately the following:

/* Here, "dirty" really means, "call set_page_dirty_lock()": */ void __put_user_pages(struct page **pages, unsigned long npages,

		      bool dirty);

/* Here, "dirty" really means, "call set_page_dirty()": */ void __put_user_pages_unlocked(struct page **pages, unsigned long npages,

			       bool dirty);

?

thanks,

Signature · 6 lines
John Hubbard
NVIDIA
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
#4 lore raw

Re: [PATCH 1/3] mm/gup: introduce __put_user_pages()

Quoted 4 lines · John Hubbard

I'm seeing about 18 places where set_page_dirty() is used, in the call site conversions so far, and about 20 places where set_page_dirty_lock() is used. So without knowing how many of the former (if any) represent bugs, you can see why the proposal here supports both DIRTY and DIRTY_LOCK.

Well, it should be fairly easy to audit. set_page_dirty() is only safe if we are dealing with a file backed page where we have reference on the inode it hangs off. Which should basically be never or almost never.

#5 lore raw

PATCH 2/3 drivers/gpu/drm/via: convert put_page() to put_user_page*()

In reply to [email protected]

From: John Hubbard <[email protected]>

For pages that were retained via get_user_pages*(), release those pages via the new put_user_page*() routines, instead of via put_page() or release_pages().

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

Also reverse the order of a comparison, in order to placate checkpatch.pl.

---
 drivers/gpu/drm/via/via_dmablit.c | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)
drivers/gpu/drm/via/via_dmablit.c +3 -8
index 062067438f1d..754f2bb97d61 100644
@@ -171,7 +171,6 @@ via_map_blit_for_device(struct pci_dev *pdev,
 static void
 via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 {
-	struct page *page;
 	int i;
 
 	switch (vsg->state) {
@@ -186,13 +185,9 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
 		kfree(vsg->desc_pages);
 		/* fall through */
 	case dr_via_pages_locked:
-		for (i = 0; i < vsg->num_pages; ++i) {
-			if (NULL != (page = vsg->pages[i])) {
-				if (!PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
-					SetPageDirty(page);
-				put_page(page);
-			}
-		}
+		__put_user_pages(vsg->pages, vsg->num_pages,
+				 (vsg->direction == DMA_FROM_DEVICE) ?
+				 PUP_FLAGS_DIRTY : PUP_FLAGS_CLEAN);
 		/* fall through */
 	case dr_via_pages_alloc:
 		vfree(vsg->pages);
Signature · 1 line
2.22.0
#6 lore raw

PATCH 3/3 net/xdp: convert put_page() to put_user_page*()

In reply to [email protected]

From: John Hubbard <[email protected]>

For pages that were retained via get_user_pages*(), release those pages via the new put_user_page*() routines, instead of via put_page() or release_pages().

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

Cc Björn Töpel <[email protected]>
Cc Magnus Karlsson <[email protected]>
Cc David S. Miller <[email protected]>
---
 net/xdp/xdp_umem.c | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)
net/xdp/xdp_umem.c +1 -8
index 83de74ca729a..0325a17915de 100644
@@ -166,14 +166,7 @@ void xdp_umem_clear_dev(struct xdp_umem *umem)
 
 static void xdp_umem_unpin_pages(struct xdp_umem *umem)
 {
-	unsigned int i;
-
-	for (i = 0; i < umem->npgs; i++) {
-		struct page *page = umem->pgs[i];
-
-		set_page_dirty_lock(page);
-		put_page(page);
-	}
+	put_user_pages_dirty_lock(umem->pgs, umem->npgs);
 
 	kfree(umem->pgs);
 	umem->pgs = NULL;
Signature · 1 line
2.22.0
#7 lore raw

Re: [PATCH 3/3] net/xdp: convert put_page() to put_user_page*()

Quoted 25 lines · On Mon, Jul 22, 2019 at 03:34:15PM -0700, [email protected] wrote:

From: John Hubbard <[email protected]>

For pages that were retained via get_user_pages*(), release those pages via the new put_user_page*() routines, instead of via put_page() or release_pages().

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

Cc Björn Töpel <[email protected]>
Cc Magnus Karlsson <[email protected]>
Cc David S. Miller <[email protected]>
---
 net/xdp/xdp_umem.c | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)
net/xdp/xdp_umem.c +0 -0
index 83de74ca729a..0325a17915de 100644
@@ -166,14 +166,7 @@ void xdp_umem_clear_dev(struct xdp_umem *umem)
 
 static void xdp_umem_unpin_pages(struct xdp_umem *umem)

net/xdp/xdp_umem.c void xdp_umem_clear_dev(struct xdp_umem *umem) · line 169

Quoted 10 lines
net/xdp/xdp_umem.c +1 -8
 {
-	unsigned int i;
-
-	for (i = 0; i < umem->npgs; i++) {
-		struct page *page = umem->pgs[i];
-
-		set_page_dirty_lock(page);
-		put_page(page);
-	}
+	put_user_pages_dirty_lock(umem->pgs, umem->npgs);

What is the difference between this and

__put_user_pages(umem->pgs, umem->npgs, PUP_FLAGS_DIRTY_LOCK);

?

I'm a bit concerned with adding another form of the same interface. We should either have 1 call with flags (enum in this case) or multiple calls. Given the previous discussion lets move in the direction of having the enum but don't introduce another caller of the "old" interface.

So I think on this patch NAK from me.

I also don't like having a __* call in the exported interface but there is a __get_user_pages_fast() call so I guess there is precedent. :-/

Ira

Quoted 6 lines
net/xdp/xdp_umem.c +0 -0
 	kfree(umem->pgs);
 	umem->pgs = NULL;
Signature · 1 line
2.22.0
reviewer
#8 lore raw

Re: [PATCH 3/3] net/xdp: convert put_page() to put_user_page*()

Quoted 39 lines · Ira Weiny
Quoted 25 lines · On Mon, Jul 22, 2019 at 03:34:15PM -0700, [email protected] wrote:

From: John Hubbard <[email protected]>

For pages that were retained via get_user_pages*(), release those pages via the new put_user_page*() routines, instead of via put_page() or release_pages().

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

Cc Björn Töpel <[email protected]>
Cc Magnus Karlsson <[email protected]>
Cc David S. Miller <[email protected]>
---
  net/xdp/xdp_umem.c | 9 +--------
  1 file changed, 1 insertion(+), 8 deletions(-)
net/xdp/xdp_umem.c +0 -0
index 83de74ca729a..0325a17915de 100644
@@ -166,14 +166,7 @@ void xdp_umem_clear_dev(struct xdp_umem *umem)
 
  static void xdp_umem_unpin_pages(struct xdp_umem *umem)

net/xdp/xdp_umem.c void xdp_umem_clear_dev(struct xdp_umem *umem) · line 169

Quoted 10 lines
net/xdp/xdp_umem.c +1 -8
  {
-	unsigned int i;
-
-	for (i = 0; i < umem->npgs; i++) {
-		struct page *page = umem->pgs[i];
-
-		set_page_dirty_lock(page);
-		put_page(page);
-	}
+	put_user_pages_dirty_lock(umem->pgs, umem->npgs);

What is the difference between this and

Quoted 3 lines

__put_user_pages(umem->pgs, umem->npgs, PUP_FLAGS_DIRTY_LOCK);

?

No difference.

Quoted 5 lines

I'm a bit concerned with adding another form of the same interface. We should either have 1 call with flags (enum in this case) or multiple calls. Given the previous discussion lets move in the direction of having the enum but don't introduce another caller of the "old" interface.

I disagree that this is a "problem". There is no maintenance pitfall here; there are merely two ways to call the put_user_page*() API. Both are correct, and neither one will get you into trouble.

Not only that, but there is ample precedent for this approach in other kernel APIs.

Quoted 6 lines

So I think on this patch NAK from me.

I also don't like having a __* call in the exported interface but there is a __get_user_pages_fast() call so I guess there is precedent. :-/

I thought about this carefully, and looked at other APIs. And I noticed that things like __get_user_pages*() are how it's often done:

* The leading underscores are often used for the more elaborate form of the call (as oppposed to decorating the core function name with "_flags", for example).

* There are often calls in which you can either call the simpler form, or the form with flags and additional options, and yes, you'll get the same result.

Obviously, this stuff is all subject to a certain amount of opinion, but I think I'm on really solid ground as far as precedent goes. So I'm pushing back on the NAK... :)

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#9 lore raw

Re: [PATCH 3/3] net/xdp: convert put_page() to put_user_page*()

Quoted 3 lines · John Hubbard

* The leading underscores are often used for the more elaborate form of the call (as oppposed to decorating the core function name with "_flags", for example).

IMHO usually the __ version of a public symbol means something like 'why are you using this? you probably should not'

Often because the __ version has no locking or some other dangerous configuration like that.

Jason

#10 lore raw

Re: [PATCH 3/3] net/xdp: convert put_page() to put_user_page*()

In reply to John Hubbard
Quoted 72 lines · John Hubbard
Quoted 38 lines · Ira Weiny
Quoted 24 lines · On Mon, Jul 22, 2019 at 03:34:15PM -0700, [email protected] wrote:

From: John Hubbard <[email protected]>

For pages that were retained via get_user_pages*(), release those pages via the new put_user_page*() routines, instead of via put_page() or release_pages().

This is part a tree-wide conversion, as described in commit fc1d8e7cca2d ("mm: introduce put_user_page*(), placeholder versions").

Cc Björn Töpel <[email protected]>
Cc Magnus Karlsson <[email protected]>
Cc David S. Miller <[email protected]>
---
  net/xdp/xdp_umem.c | 9 +--------
  1 file changed, 1 insertion(+), 8 deletions(-)
net/xdp/xdp_umem.c +0 -0
index 83de74ca729a..0325a17915de 100644
@@ -166,14 +166,7 @@ void xdp_umem_clear_dev(struct xdp_umem *umem)
  static void xdp_umem_unpin_pages(struct xdp_umem *umem)

net/xdp/xdp_umem.c void xdp_umem_clear_dev(struct xdp_umem *umem) · line 168

Quoted 10 lines
net/xdp/xdp_umem.c +1 -8
  {
-	unsigned int i;
-
-	for (i = 0; i < umem->npgs; i++) {
-		struct page *page = umem->pgs[i];
-
-		set_page_dirty_lock(page);
-		put_page(page);
-	}
+	put_user_pages_dirty_lock(umem->pgs, umem->npgs);

What is the difference between this and

Quoted 3 lines

__put_user_pages(umem->pgs, umem->npgs, PUP_FLAGS_DIRTY_LOCK);

?

No difference.

Quoted 5 lines

I'm a bit concerned with adding another form of the same interface. We should either have 1 call with flags (enum in this case) or multiple calls. Given the previous discussion lets move in the direction of having the enum but don't introduce another caller of the "old" interface.

I disagree that this is a "problem". There is no maintenance pitfall here; there are merely two ways to call the put_user_page*() API. Both are correct, and neither one will get you into trouble.

Not only that, but there is ample precedent for this approach in other kernel APIs.

Quoted 6 lines

So I think on this patch NAK from me.

I also don't like having a __* call in the exported interface but there is a __get_user_pages_fast() call so I guess there is precedent. :-/

I thought about this carefully, and looked at other APIs. And I noticed that things like __get_user_pages*() are how it's often done:

* The leading underscores are often used for the more elaborate form of the call (as oppposed to decorating the core function name with "_flags", for example).

Quoted 6 lines

* There are often calls in which you can either call the simpler form, or the form with flags and additional options, and yes, you'll get the same result.

Obviously, this stuff is all subject to a certain amount of opinion, but I think I'm on really solid ground as far as precedent goes. So I'm pushing back on the NAK... :)

Fair enough... However, we have discussed in the past how GUP can be a confusing interface to use.

So I'd like to see it be more directed. Only using the __put_user_pages() version allows us to ID callers easier through a grep of PUP_FLAGS_DIRTY_LOCK in addition to directing users to use that interface rather than having to read the GUP code to figure out that the 2 calls above are equal. It is not a huge deal but...

Ira

Quoted 6 lines

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
reviewer
#11 lore raw

Re: [PATCH 3/3] net/xdp: convert put_page() to put_user_page*()

Quoted 3 lines · Ira Weiny
Quoted 2 lines · John Hubbard
Quoted 1 line · Ira Weiny

On Mon, Jul 22, 2019 at 03:34:15PM -0700, [email protected] wrote:

...

Quoted 4 lines
Quoted 3 lines

Obviously, this stuff is all subject to a certain amount of opinion, but I think I'm on really solid ground as far as precedent goes. So I'm pushing back on the NAK... :)

Quoted 9 lines

Fair enough... However, we have discussed in the past how GUP can be a confusing interface to use.

So I'd like to see it be more directed. Only using the __put_user_pages() version allows us to ID callers easier through a grep of PUP_FLAGS_DIRTY_LOCK in addition to directing users to use that interface rather than having to read the GUP code to figure out that the 2 calls above are equal. It is not a huge deal but...

OK, combining all the feedback to date, which is:

* the leading double underscore is unloved,

* set_page_dirty() is under investigation, but likely guilty of incitement to cause bugs,

...we end up with this:

void put_user_pages_dirty_lock(struct page **pages, unsigned long npages,
bool make_dirty)

...which I have a v2 patchset for, ready to send out. It makes IB all pretty too. :)

thanks,

Signature · 2 lines
John Hubbard
NVIDIA