Message ID | 20190211201643.7599-3-ira.weiny@intel.com (mailing list archive) |
---|---|
State | Changes Requested |
Headers | show |
Series | Add gup fast + longterm and use it in HFI1 | expand |
On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > From: Ira Weiny <ira.weiny@intel.com> > > Users of get_user_pages_fast are not protected against mapping > pages within FS DAX. Introduce a call which protects them. > > We do this by checking for DEVMAP pages during the fast walk and > falling back to the longterm gup call to check for FS DAX if needed. > > Signed-off-by: Ira Weiny <ira.weiny@intel.com> > include/linux/mm.h | 8 ++++ > mm/gup.c | 102 +++++++++++++++++++++++++++++++++++---------- > 2 files changed, 88 insertions(+), 22 deletions(-) > > diff --git a/include/linux/mm.h b/include/linux/mm.h > index 80bb6408fe73..8f831c823630 100644 > +++ b/include/linux/mm.h > @@ -1540,6 +1540,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages, > long get_user_pages_longterm(unsigned long start, unsigned long nr_pages, > unsigned int gup_flags, struct page **pages, > struct vm_area_struct **vmas); > +int get_user_pages_fast_longterm(unsigned long start, int nr_pages, bool write, > + struct page **pages); > #else > static inline long get_user_pages_longterm(unsigned long start, > unsigned long nr_pages, unsigned int gup_flags, > @@ -1547,6 +1549,11 @@ static inline long get_user_pages_longterm(unsigned long start, > { > return get_user_pages(start, nr_pages, gup_flags, pages, vmas); > } > +static inline int get_user_pages_fast_longterm(unsigned long start, int nr_pages, > + bool write, struct page **pages) > +{ > + return get_user_pages_fast(start, nr_pages, write, pages); > +} > #endif /* CONFIG_FS_DAX */ > > int get_user_pages_fast(unsigned long start, int nr_pages, int write, > @@ -2615,6 +2622,7 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address, > #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ > #define FOLL_COW 0x4000 /* internal GUP flag */ > #define FOLL_ANON 0x8000 /* don't do file mappings */ > +#define FOLL_LONGTERM 0x10000 /* mapping is intended for a long term pin */ If we are adding a new flag, maybe we should get rid of the 'longterm' entry points and just rely on the callers to pass the flag? Jason
On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: >> From: Ira Weiny <ira.weiny@intel.com> [...] >> +static inline int get_user_pages_fast_longterm(unsigned long start, int nr_pages, >> + bool write, struct page **pages) >> +{ >> + return get_user_pages_fast(start, nr_pages, write, pages); >> +} >> #endif /* CONFIG_FS_DAX */ >> >> int get_user_pages_fast(unsigned long start, int nr_pages, int write, >> @@ -2615,6 +2622,7 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address, >> #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ >> #define FOLL_COW 0x4000 /* internal GUP flag */ >> #define FOLL_ANON 0x8000 /* don't do file mappings */ >> +#define FOLL_LONGTERM 0x10000 /* mapping is intended for a long term pin */ > > If we are adding a new flag, maybe we should get rid of the 'longterm' > entry points and just rely on the callers to pass the flag? > > Jason > +1, I agree that the overall get_user_pages*() API family will be cleaner *without* get_user_pages_longterm*() calls. And this new flag makes that possible. So I'd like to see the "longerm" call replaced with just passing this flag. Maybe even as part of this patchset, but either way. Taking a moment to reflect on where I think this might go eventually (the notes below do not need to affect your patchset here, but this seems like a good place to mention this): It seems to me that the longterm vs. short-term is of questionable value. It's actually better to just call get_user_pages(), and then if it really is long-term enough to matter internally, we'll see the pages marked as gup-pinned. If the gup pages are released before anyone (filesystem, that is) notices, then it must have been short term. Doing it that way is self-maintaining. Of course, this assumes that we end up with a design that doesn't require being told, by the call sites, that a given gup call is intended for "long term" use. So I could be wrong about this direction, but let's please consider the possibility. thanks,
On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > > On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > >> From: Ira Weiny <ira.weiny@intel.com> > [...] > >> +static inline int get_user_pages_fast_longterm(unsigned long start, int nr_pages, > >> + bool write, struct page **pages) > >> +{ > >> + return get_user_pages_fast(start, nr_pages, write, pages); > >> +} > >> #endif /* CONFIG_FS_DAX */ > >> > >> int get_user_pages_fast(unsigned long start, int nr_pages, int write, > >> @@ -2615,6 +2622,7 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address, > >> #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ > >> #define FOLL_COW 0x4000 /* internal GUP flag */ > >> #define FOLL_ANON 0x8000 /* don't do file mappings */ > >> +#define FOLL_LONGTERM 0x10000 /* mapping is intended for a long term pin */ > > > > If we are adding a new flag, maybe we should get rid of the 'longterm' > > entry points and just rely on the callers to pass the flag? > > > > Jason > > > > +1, I agree that the overall get_user_pages*() API family will be cleaner > *without* get_user_pages_longterm*() calls. And this new flag makes that possible. > So I'd like to see the "longerm" call replaced with just passing this flag. Maybe > even as part of this patchset, but either way. Yes I've thought about this as well. I have a couple of different versions of this series which I've been mulling over and this was one of the other variations. But see below... > > Taking a moment to reflect on where I think this might go eventually (the notes > below do not need to affect your patchset here, but this seems like a good place > to mention this): > > It seems to me that the longterm vs. short-term is of questionable value. This is exactly why I did not post this before. I've been waiting our other discussions on how GUP pins are going to be handled to play out. But with the netdev thread today[1] it seems like we need to make sure we have a "safe" fast variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to do that even if we will not need the distinction in the future... :-( > It's actually better to just call get_user_pages(), and then if it really is > long-term enough to matter internally, we'll see the pages marked as gup-pinned. > If the gup pages are released before anyone (filesystem, that is) notices, then > it must have been short term. > > Doing it that way is self-maintaining. Of course, this assumes that we end up with > a design that doesn't require being told, by the call sites, that a given gup > call is intended for "long term" use. So I could be wrong about this direction, but > let's please consider the possibility. This is why I've been holding these patches. I'm also not 100% sure if we will need the longterm flag in the future. This is also why I did not change the get_user_pages_longterm because we could be ripping this all out by the end of the year... (I hope. :-) So while this does "pollute" the GUP family of calls I'm hoping it is not forever. Ira [1] https://lkml.org/lkml/2019/2/11/1789 > > thanks, > -- > John Hubbard > NVIDIA
On 2/11/19 1:26 PM, Ira Weiny wrote: > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: >>>> From: Ira Weiny <ira.weiny@intel.com> >> [...] >> It seems to me that the longterm vs. short-term is of questionable value. > > This is exactly why I did not post this before. I've been waiting our other > discussions on how GUP pins are going to be handled to play out. But with the > netdev thread today[1] it seems like we need to make sure we have a "safe" fast > variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to > do that even if we will not need the distinction in the future... :-( Yes, I agree. Below... > [...] > This is also why I did not change the get_user_pages_longterm because we could > be ripping this all out by the end of the year... (I hope. :-) > > So while this does "pollute" the GUP family of calls I'm hoping it is not > forever. > > Ira > > [1] https://lkml.org/lkml/2019/2/11/1789 > Yes, and to be clear, I think your patchset here is fine. It is easy to find the FOLL_LONGTERM callers if and when we want to change anything. I just think also it's appopriate to go a bit further, and use FOLL_LONGTERM all by itself. That's because in either design outcome, it's better that way: -- If we keep the concept of "I'm a long-term gup call site", then FOLL_LONGTERM is just right. The gup API already has _fast and non-fast variants, and once you get past a couple, you end up with a multiplication of names that really work better as flags. We're there. -- If we drop the concept, then you've already done part of the work, by removing the _longterm API variants. thanks,
On Mon, Feb 11, 2019 at 1:39 PM John Hubbard <jhubbard@nvidia.com> wrote: > > On 2/11/19 1:26 PM, Ira Weiny wrote: > > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > >>>> From: Ira Weiny <ira.weiny@intel.com> > >> [...] > >> It seems to me that the longterm vs. short-term is of questionable value. > > > > This is exactly why I did not post this before. I've been waiting our other > > discussions on how GUP pins are going to be handled to play out. But with the > > netdev thread today[1] it seems like we need to make sure we have a "safe" fast > > variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to > > do that even if we will not need the distinction in the future... :-( > > Yes, I agree. Below... > > > [...] > > This is also why I did not change the get_user_pages_longterm because we could > > be ripping this all out by the end of the year... (I hope. :-) > > > > So while this does "pollute" the GUP family of calls I'm hoping it is not > > forever. > > > > Ira > > > > [1] https://lkml.org/lkml/2019/2/11/1789 > > > > Yes, and to be clear, I think your patchset here is fine. It is easy to find > the FOLL_LONGTERM callers if and when we want to change anything. I just think > also it's appopriate to go a bit further, and use FOLL_LONGTERM all by itself. > > That's because in either design outcome, it's better that way: > > -- If we keep the concept of "I'm a long-term gup call site", then FOLL_LONGTERM > is just right. The gup API already has _fast and non-fast variants, and once > you get past a couple, you end up with a multiplication of names that really > work better as flags. We're there. > > -- If we drop the concept, then you've already done part of the work, by removing > the _longterm API variants. > A problem I now see with the _longterm name is that it hides its true intent. It's really a "dax can't use page cache tricks to make it seem like this page is ok to access indefinitely, if the system needs this page back your pin would prevent the forward progress of the system state.". If the discussion results in a need to have an explicit file state (immutable or lease) then we'll continue to need a gup pin type distinction. If the discussion resolves to one of the silent options (fail truncate, lie about truncate) then FOLL_LONGTERM might be able to die at that point.
On Mon, Feb 11, 2019 at 01:39:12PM -0800, John Hubbard wrote: > On 2/11/19 1:26 PM, Ira Weiny wrote: > > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > >>>> From: Ira Weiny <ira.weiny@intel.com> > >> [...] > >> It seems to me that the longterm vs. short-term is of questionable value. > > > > This is exactly why I did not post this before. I've been waiting our other > > discussions on how GUP pins are going to be handled to play out. But with the > > netdev thread today[1] it seems like we need to make sure we have a "safe" fast > > variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to > > do that even if we will not need the distinction in the future... :-( > > Yes, I agree. Below... > > > [...] > > This is also why I did not change the get_user_pages_longterm because we could > > be ripping this all out by the end of the year... (I hope. :-) > > > > So while this does "pollute" the GUP family of calls I'm hoping it is not > > forever. > > > > Ira > > > > [1] https://lkml.org/lkml/2019/2/11/1789 > > > > Yes, and to be clear, I think your patchset here is fine. It is easy to find > the FOLL_LONGTERM callers if and when we want to change anything. I just think > also it's appopriate to go a bit further, and use FOLL_LONGTERM all by itself. > > That's because in either design outcome, it's better that way: > > -- If we keep the concept of "I'm a long-term gup call site", then FOLL_LONGTERM > is just right. The gup API already has _fast and non-fast variants, and once > you get past a couple, you end up with a multiplication of names that really > work better as flags. We're there. > > -- If we drop the concept, then you've already done part of the work, by removing > the _longterm API variants. Fair enough. But to do that correctly I think we will need to convert get_user_pages_fast() to use flags as well. I have a version of this series which includes a patch does this, but the patch touched a lot of subsystems and a couple of different architectures...[1] I can't test them all. If we want to go that way I'm up for submitting the patch... But if we remove longterm in the future we may be left with a get_user_pages_fast() which really only needs 1 flag. But perhaps overall we would be better off? Ira [1] mm/gup.c: Change GUP fast to use flags rather than write bool To facilitate additional options to get_user_pages_fast change the singular write parameter to be the more generic gup_flags. This patch currently does not change any functionality. New functionality will follow in subsequent patches. Many of the get_user_pages_fast call sites were unchanged because they already used FOLL_WRITE or 0 as appropriate. Signed-off-by: Ira Weiny <ira.weiny@intel.com> --- arch/mips/mm/gup.c | 11 ++++++----- arch/powerpc/kvm/book3s_64_mmu_hv.c | 4 ++-- arch/powerpc/kvm/e500_mmu.c | 2 +- arch/powerpc/mm/mmu_context_iommu.c | 4 ++-- arch/s390/kvm/interrupt.c | 2 +- arch/s390/mm/gup.c | 12 ++++++------ arch/sh/mm/gup.c | 11 ++++++----- arch/sparc/mm/gup.c | 9 +++++---- arch/x86/kvm/paging_tmpl.h | 2 +- arch/x86/kvm/svm.c | 2 +- drivers/fpga/dfl-afu-dma-region.c | 2 +- drivers/gpu/drm/via/via_dmablit.c | 3 ++- drivers/infiniband/hw/hfi1/user_pages.c | 3 ++- drivers/misc/genwqe/card_utils.c | 2 +- drivers/misc/vmw_vmci/vmci_host.c | 2 +- drivers/misc/vmw_vmci/vmci_queue_pair.c | 6 ++++-- drivers/platform/goldfish/goldfish_pipe.c | 3 ++- drivers/rapidio/devices/rio_mport_cdev.c | 4 +++- drivers/sbus/char/oradax.c | 2 +- drivers/scsi/st.c | 3 ++- drivers/staging/gasket/gasket_page_table.c | 4 ++-- drivers/tee/tee_shm.c | 2 +- drivers/vfio/vfio_iommu_spapr_tce.c | 3 ++- drivers/vhost/vhost.c | 2 +- drivers/video/fbdev/pvr2fb.c | 2 +- drivers/virt/fsl_hypervisor.c | 2 +- drivers/xen/gntdev.c | 2 +- fs/orangefs/orangefs-bufmap.c | 2 +- include/linux/mm.h | 4 ++-- kernel/futex.c | 2 +- lib/iov_iter.c | 7 +++++-- mm/gup.c | 10 +++++----- mm/util.c | 8 ++++---- net/ceph/pagevec.c | 2 +- net/rds/info.c | 2 +- net/rds/rdma.c | 3 ++- 36 files changed, 81 insertions(+), 65 deletions(-)
On 2/11/19 1:52 PM, Ira Weiny wrote: > On Mon, Feb 11, 2019 at 01:39:12PM -0800, John Hubbard wrote: >> On 2/11/19 1:26 PM, Ira Weiny wrote: >>> On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: >>>> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: >>>>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: >>>>>> From: Ira Weiny <ira.weiny@intel.com> >>>> [...] > Fair enough. But to do that correctly I think we will need to convert > get_user_pages_fast() to use flags as well. I have a version of this series > which includes a patch does this, but the patch touched a lot of subsystems and > a couple of different architectures...[1] > > I can't test them all. If we want to go that way I'm up for submitting the I have a similar problem, and a similar list of call sites, for the put_user_pages() conversion, so that file list looks familiar. And the arch-specific gup implementations are about to complicate my life too. :) > patch... But if we remove longterm in the future we may be left with a > get_user_pages_fast() which really only needs 1 flag. But perhaps overall we > would be better off? > > Ira I certainly think so, yes. thanks,
On Mon, Feb 11, 2019 at 01:52:38PM -0800, Ira Weiny wrote: > On Mon, Feb 11, 2019 at 01:39:12PM -0800, John Hubbard wrote: > > On 2/11/19 1:26 PM, Ira Weiny wrote: > > > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > > >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > > >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > > >>>> From: Ira Weiny <ira.weiny@intel.com> > > >> [...] > > >> It seems to me that the longterm vs. short-term is of questionable value. > > > > > > This is exactly why I did not post this before. I've been waiting our other > > > discussions on how GUP pins are going to be handled to play out. But with the > > > netdev thread today[1] it seems like we need to make sure we have a "safe" fast > > > variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to > > > do that even if we will not need the distinction in the future... :-( > > > > Yes, I agree. Below... > > > > > [...] > > > This is also why I did not change the get_user_pages_longterm because we could > > > be ripping this all out by the end of the year... (I hope. :-) > > > > > > So while this does "pollute" the GUP family of calls I'm hoping it is not > > > forever. > > > > > > Ira > > > > > > [1] https://lkml.org/lkml/2019/2/11/1789 > > > > > > > Yes, and to be clear, I think your patchset here is fine. It is easy to find > > the FOLL_LONGTERM callers if and when we want to change anything. I just think > > also it's appopriate to go a bit further, and use FOLL_LONGTERM all by itself. > > > > That's because in either design outcome, it's better that way: > > > > is just right. The gup API already has _fast and non-fast variants, and once > > you get past a couple, you end up with a multiplication of names that really > > work better as flags. We're there. > > > > the _longterm API variants. > > Fair enough. But to do that correctly I think we will need to convert > get_user_pages_fast() to use flags as well. I have a version of this series > which includes a patch does this, but the patch touched a lot of subsystems and > a couple of different architectures...[1] I think this should be done anyhow, it is trouble the two basically identical interfaces have different signatures. This already caused a bug in vfio.. I also wonder if someone should think about making fast into a flag too.. But I'm not sure when fast should be used vs when it shouldn't :( Jason
On Mon, Feb 11, 2019 at 2:07 PM Jason Gunthorpe <jgg@ziepe.ca> wrote: > > On Mon, Feb 11, 2019 at 01:52:38PM -0800, Ira Weiny wrote: > > On Mon, Feb 11, 2019 at 01:39:12PM -0800, John Hubbard wrote: > > > On 2/11/19 1:26 PM, Ira Weiny wrote: > > > > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > > > >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > > > >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com wrote: > > > >>>> From: Ira Weiny <ira.weiny@intel.com> > > > >> [...] > > > >> It seems to me that the longterm vs. short-term is of questionable value. > > > > > > > > This is exactly why I did not post this before. I've been waiting our other > > > > discussions on how GUP pins are going to be handled to play out. But with the > > > > netdev thread today[1] it seems like we need to make sure we have a "safe" fast > > > > variant for a while. Introducing FOLL_LONGTERM seemed like the cleanest way to > > > > do that even if we will not need the distinction in the future... :-( > > > > > > Yes, I agree. Below... > > > > > > > [...] > > > > This is also why I did not change the get_user_pages_longterm because we could > > > > be ripping this all out by the end of the year... (I hope. :-) > > > > > > > > So while this does "pollute" the GUP family of calls I'm hoping it is not > > > > forever. > > > > > > > > Ira > > > > > > > > [1] https://lkml.org/lkml/2019/2/11/1789 > > > > > > > > > > Yes, and to be clear, I think your patchset here is fine. It is easy to find > > > the FOLL_LONGTERM callers if and when we want to change anything. I just think > > > also it's appopriate to go a bit further, and use FOLL_LONGTERM all by itself. > > > > > > That's because in either design outcome, it's better that way: > > > > > > is just right. The gup API already has _fast and non-fast variants, and once > > > you get past a couple, you end up with a multiplication of names that really > > > work better as flags. We're there. > > > > > > the _longterm API variants. > > > > Fair enough. But to do that correctly I think we will need to convert > > get_user_pages_fast() to use flags as well. I have a version of this series > > which includes a patch does this, but the patch touched a lot of subsystems and > > a couple of different architectures...[1] > > I think this should be done anyhow, it is trouble the two basically > identical interfaces have different signatures. This already caused a > bug in vfio.. > > I also wonder if someone should think about making fast into a flag > too.. > > But I'm not sure when fast should be used vs when it shouldn't :( Effectively fast should always be used just in case the user cares about performance. It's just that it may fail and need to fall back to requiring the vma. Personally I thought RDMA memory registration is a one-time / upfront slow path so that non-fast-GUP is tolerable. The workloads that *need* it are O_DIRECT users that can't tolerate a vma lookup on every I/O.
> > On Mon, Feb 11, 2019 at 2:07 PM Jason Gunthorpe <jgg@ziepe.ca> wrote: > > > > On Mon, Feb 11, 2019 at 01:52:38PM -0800, Ira Weiny wrote: > > > On Mon, Feb 11, 2019 at 01:39:12PM -0800, John Hubbard wrote: > > > > On 2/11/19 1:26 PM, Ira Weiny wrote: > > > > > On Mon, Feb 11, 2019 at 01:13:56PM -0800, John Hubbard wrote: > > > > >> On 2/11/19 12:39 PM, Jason Gunthorpe wrote: > > > > >>> On Mon, Feb 11, 2019 at 12:16:42PM -0800, ira.weiny@intel.com > wrote: > > > > >>>> From: Ira Weiny <ira.weiny@intel.com> > > > > >> [...] > > > > >> It seems to me that the longterm vs. short-term is of questionable > value. > > > > > > > > > > This is exactly why I did not post this before. I've been > > > > > waiting our other discussions on how GUP pins are going to be > > > > > handled to play out. But with the netdev thread today[1] it > > > > > seems like we need to make sure we have a "safe" fast variant > > > > > for a while. Introducing FOLL_LONGTERM seemed like the cleanest > > > > > way to do that even if we will not need the distinction in the > > > > > future... :-( > > > > > > > > Yes, I agree. Below... > > > > > > > > > [...] > > > > > This is also why I did not change the get_user_pages_longterm > > > > > because we could be ripping this all out by the end of the > > > > > year... (I hope. :-) > > > > > > > > > > So while this does "pollute" the GUP family of calls I'm hoping > > > > > it is not forever. > > > > > > > > > > Ira > > > > > > > > > > [1] https://lkml.org/lkml/2019/2/11/1789 > > > > > > > > > > > > > Yes, and to be clear, I think your patchset here is fine. It is > > > > easy to find the FOLL_LONGTERM callers if and when we want to > > > > change anything. I just think also it's appopriate to go a bit further, and > use FOLL_LONGTERM all by itself. > > > > > > > > That's because in either design outcome, it's better that way: > > > > > > > > is just right. The gup API already has _fast and non-fast > > > > variants, and once you get past a couple, you end up with a > > > > multiplication of names that really work better as flags. We're there. > > > > > > > > the _longterm API variants. > > > > > > Fair enough. But to do that correctly I think we will need to convert > > > get_user_pages_fast() to use flags as well. I have a version of > > > this series which includes a patch does this, but the patch touched > > > a lot of subsystems and a couple of different architectures...[1] > > > > I think this should be done anyhow, it is trouble the two basically > > identical interfaces have different signatures. This already caused a > > bug in vfio.. > > > > I also wonder if someone should think about making fast into a flag > > too.. > > > > But I'm not sure when fast should be used vs when it shouldn't :( > > Effectively fast should always be used just in case the user cares about > performance. It's just that it may fail and need to fall back to requiring the > vma. > > Personally I thought RDMA memory registration is a one-time / upfront slow > path so that non-fast-GUP is tolerable. > > The workloads that *need* it are O_DIRECT users that can't tolerate a vma > lookup on every I/O. There are some users who need to [un]register memory more often. While not in the strict fast path these users would like the registrations to occur as fast as possible. I don't personally have the results but our OPA team did do performance tests on the GUP vs GUP fast and for the hfi1 case fast was better. I don't have any reason to believe that regular RDMA users would not also benefit. Ira
On Mon, Feb 11, 2019 at 02:55:10PM -0800, Dan Williams wrote: > > I also wonder if someone should think about making fast into a flag > > too.. > > > > But I'm not sure when fast should be used vs when it shouldn't :( > > Effectively fast should always be used just in case the user cares > about performance. It's just that it may fail and need to fall back to > requiring the vma. But the fall back / slow path is hidden inside the API, so when should the caller care? ie when should the caller care to use gup_fast vs gup_unlocked? (the comments say they are the same, but this seems to be a mistake) Based on some of the comments in the code it looks like this API is trying to convert itself into: long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas, bool *locked) long get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages) (and maybe a FOLL_FAST if there is some reason we have _fast and _unlocked) The reason I ask, is that if there is no reason for fast vs unlocked then maybe Ira should convert HFI to use gup_unlocked and move the 'fast' code into unlocked? ie move incrementally closer to the desired end-state here. Jason
On Mon, Feb 11, 2019 at 04:25:10PM -0700, Jason Gunthorpe wrote: > On Mon, Feb 11, 2019 at 02:55:10PM -0800, Dan Williams wrote: > > > > I also wonder if someone should think about making fast into a flag > > > too.. > > > > > > But I'm not sure when fast should be used vs when it shouldn't :( > > > > Effectively fast should always be used just in case the user cares > > about performance. It's just that it may fail and need to fall back to > > requiring the vma. > > But the fall back / slow path is hidden inside the API, so when should > the caller care? > > ie when should the caller care to use gup_fast vs gup_unlocked? (the > comments say they are the same, but this seems to be a mistake) > > Based on some of the comments in the code it looks like this API is > trying to convert itself into: > > long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm, > unsigned long start, unsigned long nr_pages, > unsigned int gup_flags, struct page **pages, > struct vm_area_struct **vmas, bool *locked) > > long get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm, > unsigned long start, unsigned long nr_pages, > unsigned int gup_flags, struct page **pages) > > (and maybe a FOLL_FAST if there is some reason we have _fast and > _unlocked) > > The reason I ask, is that if there is no reason for fast vs unlocked > then maybe Ira should convert HFI to use gup_unlocked and move the > 'fast' code into unlocked? > > ie move incrementally closer to the desired end-state here. If the pages are not in the page tables then fast is probably going to be slightly slower because it will have to fall back after walking the tables and finding something missing. For PSM2 (MPI) applications are performance improvement was probably because the memory in question was in the page tables and very much in use. Ira > > Jason
diff --git a/include/linux/mm.h b/include/linux/mm.h index 80bb6408fe73..8f831c823630 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1540,6 +1540,8 @@ long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages, long get_user_pages_longterm(unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages, struct vm_area_struct **vmas); +int get_user_pages_fast_longterm(unsigned long start, int nr_pages, bool write, + struct page **pages); #else static inline long get_user_pages_longterm(unsigned long start, unsigned long nr_pages, unsigned int gup_flags, @@ -1547,6 +1549,11 @@ static inline long get_user_pages_longterm(unsigned long start, { return get_user_pages(start, nr_pages, gup_flags, pages, vmas); } +static inline int get_user_pages_fast_longterm(unsigned long start, int nr_pages, + bool write, struct page **pages) +{ + return get_user_pages_fast(start, nr_pages, write, pages); +} #endif /* CONFIG_FS_DAX */ int get_user_pages_fast(unsigned long start, int nr_pages, int write, @@ -2615,6 +2622,7 @@ struct page *follow_page(struct vm_area_struct *vma, unsigned long address, #define FOLL_REMOTE 0x2000 /* we are working on non-current tsk/mm */ #define FOLL_COW 0x4000 /* internal GUP flag */ #define FOLL_ANON 0x8000 /* don't do file mappings */ +#define FOLL_LONGTERM 0x10000 /* mapping is intended for a long term pin */ static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags) { diff --git a/mm/gup.c b/mm/gup.c index 894ab014bd1e..f7d86a304405 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -1190,6 +1190,21 @@ long get_user_pages_longterm(unsigned long start, unsigned long nr_pages, EXPORT_SYMBOL(get_user_pages_longterm); #endif /* CONFIG_FS_DAX */ +static long get_user_pages_longterm_unlocked(unsigned long start, + unsigned long nr_pages, + struct page **pages, + unsigned int gup_flags) +{ + struct mm_struct *mm = current->mm; + long ret; + + down_read(&mm->mmap_sem); + ret = get_user_pages_longterm(start, nr_pages, gup_flags, pages, NULL); + up_read(&mm->mmap_sem); + + return ret; +} + /** * populate_vma_page_range() - populate a range of pages in the vma. * @vma: target vma @@ -1417,6 +1432,9 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, goto pte_unmap; if (pte_devmap(pte)) { + if (flags & FOLL_LONGTERM) + goto pte_unmap; + pgmap = get_dev_pagemap(pte_pfn(pte), pgmap); if (unlikely(!pgmap)) { undo_dev_pagemap(nr, nr_start, pages); @@ -1556,8 +1574,12 @@ static int gup_huge_pmd(pmd_t orig, pmd_t *pmdp, unsigned long addr, if (!pmd_access_permitted(orig, flags & FOLL_WRITE)) return 0; - if (pmd_devmap(orig)) + if (pmd_devmap(orig)) { + if (flags & FOLL_LONGTERM) + return 0; + return __gup_device_huge_pmd(orig, pmdp, addr, end, pages, nr); + } refs = 0; page = pmd_page(orig) + ((addr & ~PMD_MASK) >> PAGE_SHIFT); @@ -1837,24 +1859,9 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write, return nr; } -/** - * get_user_pages_fast() - pin user pages in memory - * @start: starting user address - * @nr_pages: number of pages from start to pin - * @write: whether pages will be written to - * @pages: array that receives pointers to the pages pinned. - * Should be at least nr_pages long. - * - * Attempt to pin user pages in memory without taking mm->mmap_sem. - * If not successful, it will fall back to taking the lock and - * calling get_user_pages(). - * - * Returns number of pages pinned. This may be fewer than the number - * requested. If nr_pages is 0 or negative, returns 0. If no pages - * were pinned, returns -errno. - */ -int get_user_pages_fast(unsigned long start, int nr_pages, int write, - struct page **pages) +static int __get_user_pages_fast_flags(unsigned long start, int nr_pages, + unsigned int gup_flags, + struct page **pages) { unsigned long addr, len, end; int nr = 0, ret = 0; @@ -1872,7 +1879,7 @@ int get_user_pages_fast(unsigned long start, int nr_pages, int write, if (gup_fast_permitted(start, nr_pages)) { local_irq_disable(); - gup_pgd_range(addr, end, write ? FOLL_WRITE : 0, pages, &nr); + gup_pgd_range(addr, end, gup_flags, pages, &nr); local_irq_enable(); ret = nr; } @@ -1882,8 +1889,14 @@ int get_user_pages_fast(unsigned long start, int nr_pages, int write, start += nr << PAGE_SHIFT; pages += nr; - ret = get_user_pages_unlocked(start, nr_pages - nr, pages, - write ? FOLL_WRITE : 0); + if (gup_flags & FOLL_LONGTERM) + ret = get_user_pages_longterm_unlocked(start, + nr_pages - nr, + pages, + gup_flags); + else + ret = get_user_pages_unlocked(start, nr_pages - nr, + pages, gup_flags); /* Have to be a bit careful with return values */ if (nr > 0) { @@ -1897,4 +1910,49 @@ int get_user_pages_fast(unsigned long start, int nr_pages, int write, return ret; } +/** + * get_user_pages_fast() - pin user pages in memory + * @start: starting user address + * @nr_pages: number of pages from start to pin + * @write: whether pages will be written to + * @pages: array that receives pointers to the pages pinned. + * Should be at least nr_pages long. + * + * Attempt to pin user pages in memory without taking mm->mmap_sem. + * If not successful, it will fall back to taking the lock and + * calling get_user_pages(). + * + * Returns number of pages pinned. This may be fewer than the number + * requested. If nr_pages is 0 or negative, returns 0. If no pages + * were pinned, returns -errno. + */ +int get_user_pages_fast(unsigned long start, int nr_pages, int write, + struct page **pages) +{ + return __get_user_pages_fast_flags(start, nr_pages, + write ? FOLL_WRITE : 0, + pages); +} + +#ifdef CONFIG_FS_DAX +/** + * get_user_pages_fast_longterm() - pin user pages in memory + * + * Exactly the same semantics as get_user_pages_fast() except fails mappings + * device mapped pages (such as DAX pages) which then fall back to checking for + * FS DAX pages with get_user_pages_longterm(). + */ +int get_user_pages_fast_longterm(unsigned long start, int nr_pages, bool write, + struct page **pages) +{ + unsigned int gup_flags = FOLL_LONGTERM; + + if (write) + gup_flags |= FOLL_WRITE; + + return __get_user_pages_fast_flags(start, nr_pages, gup_flags, pages); +} +EXPORT_SYMBOL(get_user_pages_fast_longterm); +#endif /* CONFIG_FS_DAX */ + #endif /* CONFIG_HAVE_GENERIC_GUP */