mm: change to return bool for the MMU notifier's young flag check

The MMU notifier young flag check related functions only return whether
the young flag was set.  Change the return type to bool to make the
intention clearer.

Link: https://lkml.kernel.org/r/a9ad3fe938002d87358e7bfca264f753ab602561.1774075004.git.baolin.wang@linux.alibaba.com
Signed-off-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Reviewed-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Ritesh Harjani (IBM) <ritesh.list@gmail.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 3705d350c863378083d1f5eb86a68f72556edb13..17f2cdc77dd50fc9703510d1575e48410e521bda 100644 (file)
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -97,20 +97,20 @@ struct mmu_notifier_ops {
         * Start-end is necessary in case the secondary MMU is mapping the page
         * at a smaller granularity than the primary MMU.
         */
-       int (*clear_flush_young)(struct mmu_notifier *subscription,
-                                struct mm_struct *mm,
-                                unsigned long start,
-                                unsigned long end);
+       bool (*clear_flush_young)(struct mmu_notifier *subscription,
+                                 struct mm_struct *mm,
+                                 unsigned long start,
+                                 unsigned long end);
 
        /*
         * clear_young is a lightweight version of clear_flush_young. Like the
         * latter, it is supposed to test-and-clear the young/accessed bitflag
         * in the secondary pte, but it may omit flushing the secondary tlb.
         */
-       int (*clear_young)(struct mmu_notifier *subscription,
-                          struct mm_struct *mm,
-                          unsigned long start,
-                          unsigned long end);
+       bool (*clear_young)(struct mmu_notifier *subscription,
+                           struct mm_struct *mm,
+                           unsigned long start,
+                           unsigned long end);
 
        /*
         * test_young is called to check the young/accessed bitflag in
@@ -118,9 +118,9 @@ struct mmu_notifier_ops {
         * frequently used without actually clearing the flag or tearing
         * down the secondary mapping on the page.
         */
-       int (*test_young)(struct mmu_notifier *subscription,
-                         struct mm_struct *mm,
-                         unsigned long address);
+       bool (*test_young)(struct mmu_notifier *subscription,
+                          struct mm_struct *mm,
+                          unsigned long address);
 
        /*
         * invalidate_range_start() and invalidate_range_end() must be
@@ -376,14 +376,12 @@ mmu_interval_check_retry(struct mmu_interval_notifier *interval_sub,
 
 extern void __mmu_notifier_subscriptions_destroy(struct mm_struct *mm);
 extern void __mmu_notifier_release(struct mm_struct *mm);
-extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                         unsigned long start,
-                                         unsigned long end);
-extern int __mmu_notifier_clear_young(struct mm_struct *mm,
-                                     unsigned long start,
-                                     unsigned long end);
-extern int __mmu_notifier_test_young(struct mm_struct *mm,
-                                    unsigned long address);
+bool __mmu_notifier_clear_flush_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end);
+bool __mmu_notifier_clear_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end);
+bool __mmu_notifier_test_young(struct mm_struct *mm,
+               unsigned long address);
 extern int __mmu_notifier_invalidate_range_start(struct mmu_notifier_range *r);
 extern void __mmu_notifier_invalidate_range_end(struct mmu_notifier_range *r);
 extern void __mmu_notifier_arch_invalidate_secondary_tlbs(struct mm_struct *mm,
@@ -403,30 +401,28 @@ static inline void mmu_notifier_release(struct mm_struct *mm)
                __mmu_notifier_release(mm);
 }
 
-static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                         unsigned long start,
-                                         unsigned long end)
+static inline bool mmu_notifier_clear_flush_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
        if (mm_has_notifiers(mm))
                return __mmu_notifier_clear_flush_young(mm, start, end);
-       return 0;
+       return false;
 }
 
-static inline int mmu_notifier_clear_young(struct mm_struct *mm,
-                                          unsigned long start,
-                                          unsigned long end)
+static inline bool mmu_notifier_clear_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
        if (mm_has_notifiers(mm))
                return __mmu_notifier_clear_young(mm, start, end);
-       return 0;
+       return false;
 }
 
-static inline int mmu_notifier_test_young(struct mm_struct *mm,
-                                         unsigned long address)
+static inline bool mmu_notifier_test_young(struct mm_struct *mm,
+               unsigned long address)
 {
        if (mm_has_notifiers(mm))
                return __mmu_notifier_test_young(mm, address);
-       return 0;
+       return false;
 }
 
 static inline void
@@ -552,24 +548,22 @@ static inline void mmu_notifier_release(struct mm_struct *mm)
 {
 }
 
-static inline int mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                         unsigned long start,
-                                         unsigned long end)
+static inline bool mmu_notifier_clear_flush_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
-       return 0;
+       return false;
 }
 
-static inline int mmu_notifier_clear_young(struct mm_struct *mm,
-                                          unsigned long start,
-                                          unsigned long end)
+static inline bool mmu_notifier_clear_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
-       return 0;
+       return false;
 }
 
-static inline int mmu_notifier_test_young(struct mm_struct *mm,
-                                         unsigned long address)
+static inline bool mmu_notifier_test_young(struct mm_struct *mm,
+               unsigned long address)
 {
-       return 0;
+       return false;
 }
 
 static inline void

diff --git a/mm/internal.h b/mm/internal.h
index 9ae0ee6c34f9ee50dd38451545db2483651d2518..3d3fa35e5fd1b0f009a124ea2e406deaf55ad4e4 100644 (file)
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -1860,10 +1860,10 @@ static inline int io_remap_pfn_range_complete(struct vm_area_struct *vma,
 }
 
 #ifdef CONFIG_MMU_NOTIFIER
-static inline int clear_flush_young_ptes_notify(struct vm_area_struct *vma,
+static inline bool clear_flush_young_ptes_notify(struct vm_area_struct *vma,
                unsigned long addr, pte_t *ptep, unsigned int nr)
 {
-       int young;
+       bool young;
 
        young = clear_flush_young_ptes(vma, addr, ptep, nr);
        young |= mmu_notifier_clear_flush_young(vma->vm_mm, addr,
@@ -1871,30 +1871,30 @@ static inline int clear_flush_young_ptes_notify(struct vm_area_struct *vma,
        return young;
 }
 
-static inline int pmdp_clear_flush_young_notify(struct vm_area_struct *vma,
+static inline bool pmdp_clear_flush_young_notify(struct vm_area_struct *vma,
                unsigned long addr, pmd_t *pmdp)
 {
-       int young;
+       bool young;
 
        young = pmdp_clear_flush_young(vma, addr, pmdp);
        young |= mmu_notifier_clear_flush_young(vma->vm_mm, addr, addr + PMD_SIZE);
        return young;
 }
 
-static inline int test_and_clear_young_ptes_notify(struct vm_area_struct *vma,
+static inline bool test_and_clear_young_ptes_notify(struct vm_area_struct *vma,
                unsigned long addr, pte_t *ptep, unsigned int nr)
 {
-       int young;
+       bool young;
 
        young = test_and_clear_young_ptes(vma, addr, ptep, nr);
        young |= mmu_notifier_clear_young(vma->vm_mm, addr, addr + nr * PAGE_SIZE);
        return young;
 }
 
-static inline int pmdp_test_and_clear_young_notify(struct vm_area_struct *vma,
+static inline bool pmdp_test_and_clear_young_notify(struct vm_area_struct *vma,
                unsigned long addr, pmd_t *pmdp)
 {
-       int young;
+       bool young;
 
        young = pmdp_test_and_clear_young(vma, addr, pmdp);
        young |= mmu_notifier_clear_young(vma->vm_mm, addr, addr + PMD_SIZE);

diff --git a/mm/mmu_notifier.c b/mm/mmu_notifier.c
index 2502474b83b60613d88505173fe7314c25f33730..dc6f78d559f78711df81ab0ed6e41d7a0c4051ee 100644 (file)
--- a/mm/mmu_notifier.c
+++ b/mm/mmu_notifier.c
@@ -364,12 +364,12 @@ void __mmu_notifier_release(struct mm_struct *mm)
  * unmap the address and return 1 or 0 depending if the mapping previously
  * existed or not.
  */
-int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
-                                       unsigned long start,
-                                       unsigned long end)
+bool __mmu_notifier_clear_flush_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
        struct mmu_notifier *subscription;
-       int young = 0, id;
+       bool young = false;
+       int id;
 
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_srcu(subscription,
@@ -384,12 +384,12 @@ int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
        return young;
 }
 
-int __mmu_notifier_clear_young(struct mm_struct *mm,
-                              unsigned long start,
-                              unsigned long end)
+bool __mmu_notifier_clear_young(struct mm_struct *mm,
+               unsigned long start, unsigned long end)
 {
        struct mmu_notifier *subscription;
-       int young = 0, id;
+       bool young = false;
+       int id;
 
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_srcu(subscription,
@@ -404,11 +404,12 @@ int __mmu_notifier_clear_young(struct mm_struct *mm,
        return young;
 }
 
-int __mmu_notifier_test_young(struct mm_struct *mm,
-                             unsigned long address)
+bool __mmu_notifier_test_young(struct mm_struct *mm,
+               unsigned long address)
 {
        struct mmu_notifier *subscription;
-       int young = 0, id;
+       bool young = false;
+       int id;
 
        id = srcu_read_lock(&srcu);
        hlist_for_each_entry_srcu(subscription,

diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index d0ab29672c717b39136d2f34fddfa1a6f82b7aa7..82433f46c438f0336df7aae4d9a46cdc0f0e9b31 100644 (file)
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -646,11 +646,9 @@ mmu_unlock:
        return r;
 }
 
-static __always_inline int kvm_age_hva_range(struct mmu_notifier *mn,
-                                               unsigned long start,
-                                               unsigned long end,
-                                               gfn_handler_t handler,
-                                               bool flush_on_ret)
+static __always_inline bool kvm_age_hva_range(struct mmu_notifier *mn,
+               unsigned long start, unsigned long end, gfn_handler_t handler,
+               bool flush_on_ret)
 {
        struct kvm *kvm = mmu_notifier_to_kvm(mn);
        const struct kvm_mmu_notifier_range range = {
@@ -666,10 +664,8 @@ static __always_inline int kvm_age_hva_range(struct mmu_notifier *mn,
        return kvm_handle_hva_range(kvm, &range).ret;
 }
 
-static __always_inline int kvm_age_hva_range_no_flush(struct mmu_notifier *mn,
-                                                     unsigned long start,
-                                                     unsigned long end,
-                                                     gfn_handler_t handler)
+static __always_inline bool kvm_age_hva_range_no_flush(struct mmu_notifier *mn,
+               unsigned long start, unsigned long end, gfn_handler_t handler)
 {
        return kvm_age_hva_range(mn, start, end, handler, false);
 }
@@ -829,10 +825,8 @@ static void kvm_mmu_notifier_invalidate_range_end(struct mmu_notifier *mn,
                rcuwait_wake_up(&kvm->mn_memslots_update_rcuwait);
 }
 
-static int kvm_mmu_notifier_clear_flush_young(struct mmu_notifier *mn,
-                                             struct mm_struct *mm,
-                                             unsigned long start,
-                                             unsigned long end)
+static bool kvm_mmu_notifier_clear_flush_young(struct mmu_notifier *mn,
+               struct mm_struct *mm, unsigned long start, unsigned long end)
 {
        trace_kvm_age_hva(start, end);
 
@@ -840,10 +834,8 @@ static int kvm_mmu_notifier_clear_flush_young(struct mmu_notifier *mn,
                                 !IS_ENABLED(CONFIG_KVM_ELIDE_TLB_FLUSH_IF_YOUNG));
 }
 
-static int kvm_mmu_notifier_clear_young(struct mmu_notifier *mn,
-                                       struct mm_struct *mm,
-                                       unsigned long start,
-                                       unsigned long end)
+static bool kvm_mmu_notifier_clear_young(struct mmu_notifier *mn,
+               struct mm_struct *mm, unsigned long start, unsigned long end)
 {
        trace_kvm_age_hva(start, end);
 
@@ -863,9 +855,8 @@ static int kvm_mmu_notifier_clear_young(struct mmu_notifier *mn,
        return kvm_age_hva_range_no_flush(mn, start, end, kvm_age_gfn);
 }
 
-static int kvm_mmu_notifier_test_young(struct mmu_notifier *mn,
-                                      struct mm_struct *mm,
-                                      unsigned long address)
+static bool kvm_mmu_notifier_test_young(struct mmu_notifier *mn,
+               struct mm_struct *mm, unsigned long address)
 {
        trace_kvm_test_age_hva(address);