| Message ID | 20250410035717.473207-5-bhe@redhat.com (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | mm/gup: Minor fix, cleanup and improvements | expand |
On 10.04.25 05:57, Baoquan He wrote: > The code style in fault_in_readable() and fault_in_writable() is a > little inconsistent with fault_in_safe_writeable(). In fault_in_readable() > and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While > in fault_in_safe_writeable(), local variable 'start' is used as loop > cursor. This may mislead people when reading code or making change in > these codes. > > Here define explicit loop cursor and use for loop to simplify codes in > these three functions. These cleanup can make them be consistent in > code style and improve readability. > > Signed-off-by: Baoquan He <bhe@redhat.com> > --- > mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- > 1 file changed, 26 insertions(+), 39 deletions(-) > > diff --git a/mm/gup.c b/mm/gup.c > index 77a5bc622567..a76bd7e90a71 100644 > --- a/mm/gup.c > +++ b/mm/gup.c > @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, > */ > size_t fault_in_writeable(char __user *uaddr, size_t size) > { > - char __user *start = uaddr, *end; > + const unsigned long start = (unsigned long)uaddr; > + const unsigned long end = start + size; > + unsigned long cur = start; I would initialize cur in the for loop header, makes the loop easier to read. > > if (unlikely(size == 0)) > return 0; > + Would not add that line to keep it like fault_in_readable() below. > if (!user_write_access_begin(uaddr, size)) > return size; > - if (!PAGE_ALIGNED(uaddr)) { > - unsafe_put_user(0, uaddr, out); > - uaddr = (char __user *)PAGE_ALIGN((unsigned long)uaddr); > - } > - end = (char __user *)PAGE_ALIGN((unsigned long)start + size); > - if (unlikely(end < start)) > - end = NULL; > - while (uaddr != end) { > - unsafe_put_user(0, uaddr, out); > - uaddr += PAGE_SIZE; > - } > + > + /* Stop once we overflow to 0. */ > + for (; cur && cur < end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) > + unsafe_put_user(0, (char __user *)cur, out); > Staring at fault_in_safe_writeable(), we could also do /* Stop once we overflow to 0. */ end = PAGE_ALIGN(end) if (start < end) end = 0; for (cur = start; cur != end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) unsafe_put_user(0, (char __user *)cur, out); Essentially, removing the "cur" check from the loop condition. Not sure if that is better. In any case, if all functions later look similar and clearer it's a big win.
On 04/11/25 at 10:54am, David Hildenbrand wrote: > On 10.04.25 05:57, Baoquan He wrote: > > The code style in fault_in_readable() and fault_in_writable() is a > > little inconsistent with fault_in_safe_writeable(). In fault_in_readable() > > and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While > > in fault_in_safe_writeable(), local variable 'start' is used as loop > > cursor. This may mislead people when reading code or making change in > > these codes. > > > > Here define explicit loop cursor and use for loop to simplify codes in > > these three functions. These cleanup can make them be consistent in > > code style and improve readability. > > > > Signed-off-by: Baoquan He <bhe@redhat.com> > > --- > > mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- > > 1 file changed, 26 insertions(+), 39 deletions(-) > > > > diff --git a/mm/gup.c b/mm/gup.c > > index 77a5bc622567..a76bd7e90a71 100644 > > --- a/mm/gup.c > > +++ b/mm/gup.c > > @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, > > */ > > size_t fault_in_writeable(char __user *uaddr, size_t size) > > { > > - char __user *start = uaddr, *end; > > + const unsigned long start = (unsigned long)uaddr; > > + const unsigned long end = start + size; > > + unsigned long cur = start; > > I would initialize cur in the for loop header, makes the loop easier to > read. Both is fine to me. It's to satisfy checkpatch.sh which complains about exceeding 80 char in the line. > > > if (unlikely(size == 0)) > > return 0; > > + > > Would not add that line to keep it like fault_in_readable() below. Will remove it. > > > if (!user_write_access_begin(uaddr, size)) > > return size; > > - if (!PAGE_ALIGNED(uaddr)) { > > - unsafe_put_user(0, uaddr, out); > > - uaddr = (char __user *)PAGE_ALIGN((unsigned long)uaddr); > > - } > > - end = (char __user *)PAGE_ALIGN((unsigned long)start + size); > > - if (unlikely(end < start)) > > - end = NULL; > > - while (uaddr != end) { > > - unsafe_put_user(0, uaddr, out); > > - uaddr += PAGE_SIZE; > > - } > > + > > + /* Stop once we overflow to 0. */ > > + for (; cur && cur < end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) > > + unsafe_put_user(0, (char __user *)cur, out); > > Staring at fault_in_safe_writeable(), we could also do > > /* Stop once we overflow to 0. */ > end = PAGE_ALIGN(end) > if (start < end) > end = 0; > > for (cur = start; cur != end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) > unsafe_put_user(0, (char __user *)cur, out); > > Essentially, removing the "cur" check from the loop condition. Not sure if > that is better. The current code is simpler. Your now saying may save the CPU execution instructions a little bit. Both is fine to me. I don't have strong preference, I can make v4 to address these concerns if decided. Thanks for careful checking. > > In any case, if all functions later look similar and clearer it's a big win. Agreed.
On 11.04.25 13:15, Baoquan He wrote: > On 04/11/25 at 10:54am, David Hildenbrand wrote: >> On 10.04.25 05:57, Baoquan He wrote: >>> The code style in fault_in_readable() and fault_in_writable() is a >>> little inconsistent with fault_in_safe_writeable(). In fault_in_readable() >>> and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While >>> in fault_in_safe_writeable(), local variable 'start' is used as loop >>> cursor. This may mislead people when reading code or making change in >>> these codes. >>> >>> Here define explicit loop cursor and use for loop to simplify codes in >>> these three functions. These cleanup can make them be consistent in >>> code style and improve readability. >>> >>> Signed-off-by: Baoquan He <bhe@redhat.com> >>> --- >>> mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- >>> 1 file changed, 26 insertions(+), 39 deletions(-) >>> >>> diff --git a/mm/gup.c b/mm/gup.c >>> index 77a5bc622567..a76bd7e90a71 100644 >>> --- a/mm/gup.c >>> +++ b/mm/gup.c >>> @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, >>> */ >>> size_t fault_in_writeable(char __user *uaddr, size_t size) >>> { >>> - char __user *start = uaddr, *end; >>> + const unsigned long start = (unsigned long)uaddr; >>> + const unsigned long end = start + size; >>> + unsigned long cur = start; >> >> I would initialize cur in the for loop header, makes the loop easier to >> read. > > Both is fine to me. It's to satisfy checkpatch.sh which complains about > exceeding 80 char in the line. Did checkpatch.sh actually complain? You might be happy to learn that the new limit is 100. :) [...] >> /* Stop once we overflow to 0. */ >> end = PAGE_ALIGN(end) >> if (start < end) >> end = 0; >> >> for (cur = start; cur != end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) >> unsafe_put_user(0, (char __user *)cur, out); >> >> Essentially, removing the "cur" check from the loop condition. Not sure if >> that is better. > > The current code is simpler. Your now saying may save the CPU execution > instructions a little bit. Both is fine to me. > > I don't have strong preference, I can make v4 to address these concerns > if decided. Thanks for careful checking. Whatever you prefer!
On 04/11/25 at 01:41pm, David Hildenbrand wrote: > On 11.04.25 13:15, Baoquan He wrote: > > On 04/11/25 at 10:54am, David Hildenbrand wrote: > > > On 10.04.25 05:57, Baoquan He wrote: > > > > The code style in fault_in_readable() and fault_in_writable() is a > > > > little inconsistent with fault_in_safe_writeable(). In fault_in_readable() > > > > and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While > > > > in fault_in_safe_writeable(), local variable 'start' is used as loop > > > > cursor. This may mislead people when reading code or making change in > > > > these codes. > > > > > > > > Here define explicit loop cursor and use for loop to simplify codes in > > > > these three functions. These cleanup can make them be consistent in > > > > code style and improve readability. > > > > > > > > Signed-off-by: Baoquan He <bhe@redhat.com> > > > > --- > > > > mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- > > > > 1 file changed, 26 insertions(+), 39 deletions(-) > > > > > > > > diff --git a/mm/gup.c b/mm/gup.c > > > > index 77a5bc622567..a76bd7e90a71 100644 > > > > --- a/mm/gup.c > > > > +++ b/mm/gup.c > > > > @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, > > > > */ > > > > size_t fault_in_writeable(char __user *uaddr, size_t size) > > > > { > > > > - char __user *start = uaddr, *end; > > > > + const unsigned long start = (unsigned long)uaddr; > > > > + const unsigned long end = start + size; > > > > + unsigned long cur = start; > > > > > > I would initialize cur in the for loop header, makes the loop easier to > > > read. > > > > Both is fine to me. It's to satisfy checkpatch.sh which complains about > > exceeding 80 char in the line. > > Did checkpatch.sh actually complain? You might be happy to learn that the > new limit is 100. :) That's great to know. I never noticed this and always wrap via vim's indication. > > [...] > > > > /* Stop once we overflow to 0. */ > > > end = PAGE_ALIGN(end) > > > if (start < end) > > > end = 0; > > > > > > for (cur = start; cur != end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) > > > unsafe_put_user(0, (char __user *)cur, out); > > > > > > Essentially, removing the "cur" check from the loop condition. Not sure if > > > that is better. > > > > The current code is simpler. Your now saying may save the CPU execution > > instructions a little bit. Both is fine to me. > > > > I don't have strong preference, I can make v4 to address these concerns > > if decided. Thanks for careful checking. > > Whatever you prefer! Great, will make change in v4. Thx.
On 13.04.25 03:07, Baoquan He wrote: > On 04/11/25 at 01:41pm, David Hildenbrand wrote: >> On 11.04.25 13:15, Baoquan He wrote: >>> On 04/11/25 at 10:54am, David Hildenbrand wrote: >>>> On 10.04.25 05:57, Baoquan He wrote: >>>>> The code style in fault_in_readable() and fault_in_writable() is a >>>>> little inconsistent with fault_in_safe_writeable(). In fault_in_readable() >>>>> and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While >>>>> in fault_in_safe_writeable(), local variable 'start' is used as loop >>>>> cursor. This may mislead people when reading code or making change in >>>>> these codes. >>>>> >>>>> Here define explicit loop cursor and use for loop to simplify codes in >>>>> these three functions. These cleanup can make them be consistent in >>>>> code style and improve readability. >>>>> >>>>> Signed-off-by: Baoquan He <bhe@redhat.com> >>>>> --- >>>>> mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- >>>>> 1 file changed, 26 insertions(+), 39 deletions(-) >>>>> >>>>> diff --git a/mm/gup.c b/mm/gup.c >>>>> index 77a5bc622567..a76bd7e90a71 100644 >>>>> --- a/mm/gup.c >>>>> +++ b/mm/gup.c >>>>> @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, >>>>> */ >>>>> size_t fault_in_writeable(char __user *uaddr, size_t size) >>>>> { >>>>> - char __user *start = uaddr, *end; >>>>> + const unsigned long start = (unsigned long)uaddr; >>>>> + const unsigned long end = start + size; >>>>> + unsigned long cur = start; >>>> >>>> I would initialize cur in the for loop header, makes the loop easier to >>>> read. >>> >>> Both is fine to me. It's to satisfy checkpatch.sh which complains about >>> exceeding 80 char in the line. >> >> Did checkpatch.sh actually complain? You might be happy to learn that the >> new limit is 100. :) > > That's great to know. I never noticed this and always wrap via vim's > indication. Note that coding style says: " The preferred limit on the length of a single line is 80 columns. Statements longer than 80 columns should be broken into sensible chunks, unless exceeding 80 columns significantly increases readability and does not hide information. " So 80 is still recommended, but there is nothing wrong about exceeding 80 if there is good reason.
diff --git a/mm/gup.c b/mm/gup.c index 77a5bc622567..a76bd7e90a71 100644 --- a/mm/gup.c +++ b/mm/gup.c @@ -2113,28 +2113,24 @@ static long __get_user_pages_locked(struct mm_struct *mm, unsigned long start, */ size_t fault_in_writeable(char __user *uaddr, size_t size) { - char __user *start = uaddr, *end; + const unsigned long start = (unsigned long)uaddr; + const unsigned long end = start + size; + unsigned long cur = start; if (unlikely(size == 0)) return 0; + if (!user_write_access_begin(uaddr, size)) return size; - if (!PAGE_ALIGNED(uaddr)) { - unsafe_put_user(0, uaddr, out); - uaddr = (char __user *)PAGE_ALIGN((unsigned long)uaddr); - } - end = (char __user *)PAGE_ALIGN((unsigned long)start + size); - if (unlikely(end < start)) - end = NULL; - while (uaddr != end) { - unsafe_put_user(0, uaddr, out); - uaddr += PAGE_SIZE; - } + + /* Stop once we overflow to 0. */ + for (; cur && cur < end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) + unsafe_put_user(0, (char __user *)cur, out); out: user_write_access_end(); - if (size > uaddr - start) - return size - (uaddr - start); + if (size > cur - start) + return size - (cur - start); return 0; } EXPORT_SYMBOL(fault_in_writeable); @@ -2188,26 +2184,24 @@ EXPORT_SYMBOL(fault_in_subpage_writeable); */ size_t fault_in_safe_writeable(const char __user *uaddr, size_t size) { - unsigned long start = (unsigned long)uaddr, end; + const unsigned long start = (unsigned long)uaddr; + const unsigned long end = start + size; + unsigned long cur = start; struct mm_struct *mm = current->mm; bool unlocked = false; if (unlikely(size == 0)) return 0; - end = PAGE_ALIGN(start + size); - if (end < start) - end = 0; mmap_read_lock(mm); - do { - if (fixup_user_fault(mm, start, FAULT_FLAG_WRITE, &unlocked)) + /* Stop once we overflow to 0. */ + for (; cur && cur < end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) + if (fixup_user_fault(mm, cur, FAULT_FLAG_WRITE, &unlocked)) break; - start = (start + PAGE_SIZE) & PAGE_MASK; - } while (start != end); mmap_read_unlock(mm); - if (size > start - (unsigned long)uaddr) - return size - (start - (unsigned long)uaddr); + if (size > cur - start) + return size - (cur - start); return 0; } EXPORT_SYMBOL(fault_in_safe_writeable); @@ -2222,30 +2216,23 @@ EXPORT_SYMBOL(fault_in_safe_writeable); */ size_t fault_in_readable(const char __user *uaddr, size_t size) { - const char __user *start = uaddr, *end; + const unsigned long start = (unsigned long)uaddr; + const unsigned long end = start + size; + unsigned long cur = start; volatile char c; if (unlikely(size == 0)) return 0; if (!user_read_access_begin(uaddr, size)) return size; - if (!PAGE_ALIGNED(uaddr)) { - unsafe_get_user(c, uaddr, out); - uaddr = (const char __user *)PAGE_ALIGN((unsigned long)uaddr); - } - end = (const char __user *)PAGE_ALIGN((unsigned long)start + size); - if (unlikely(end < start)) - end = NULL; - while (uaddr != end) { - unsafe_get_user(c, uaddr, out); - uaddr += PAGE_SIZE; - } - + /* Stop once we overflow to 0. */ + for (; cur && cur < end; cur = PAGE_ALIGN_DOWN(cur + PAGE_SIZE)) + unsafe_get_user(c, (const char __user *)cur, out); out: user_read_access_end(); (void)c; - if (size > uaddr - start) - return size - (uaddr - start); + if (size > cur - start) + return size - (cur - start); return 0; } EXPORT_SYMBOL(fault_in_readable);
The code style in fault_in_readable() and fault_in_writable() is a little inconsistent with fault_in_safe_writeable(). In fault_in_readable() and fault_in_writable(), it uses 'uaddr' passed in as loop cursor. While in fault_in_safe_writeable(), local variable 'start' is used as loop cursor. This may mislead people when reading code or making change in these codes. Here define explicit loop cursor and use for loop to simplify codes in these three functions. These cleanup can make them be consistent in code style and improve readability. Signed-off-by: Baoquan He <bhe@redhat.com> --- mm/gup.c | 65 +++++++++++++++++++++++--------------------------------- 1 file changed, 26 insertions(+), 39 deletions(-)