mm/gup: clean up codes in fault_in_xxx() functions

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.

[bhe@redhat.com: address minor concerns from David]
Link: https://lkml.kernel.org/r/Z/sbv3EmLXWgEE7+@MiWiFi-R3L-srv
Link: https://lkml.kernel.org/r/20250410035717.473207-5-bhe@redhat.com
Signed-off-by: Baoquan He <bhe@redhat.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Yanjun.Zhu <yanjun.zhu@linux.dev>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/gup.c b/mm/gup.c
index 77a5bc622567218e26c4bb9c201a1ebc6c5b469c..f3216833939017da5488f79abde0b8518d8623c0 100644 (file)
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -2113,28 +2113,22 @@ 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;
 
        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 = start; 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 +2182,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;
        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 = start; 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 +2214,24 @@ 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;
        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 = start; 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);