mm: rename _count, field of the struct page, to _refcount

Many developers already know that field for reference count of the
struct page is _count and atomic type.  They would try to handle it
directly and this could break the purpose of page reference count
tracepoint.  To prevent direct _count modification, this patch rename it
to _refcount and add warning message on the code.  After that, developer
who need to handle reference count will find that field should not be
accessed directly.

[akpm@linux-foundation.org: fix comments, per Vlastimil]
[akpm@linux-foundation.org: Documentation/vm/transhuge.txt too]
[sfr@canb.auug.org.au: sync ethernet driver changes]
Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Hugh Dickins <hughd@google.com>
Cc: Johannes Berg <johannes@sipsolutions.net>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Sunil Goutham <sgoutham@cavium.com>
Cc: Chris Metcalf <cmetcalf@mellanox.com>
Cc: Manish Chopra <manish.chopra@qlogic.com>
Cc: Yuval Mintz <yuval.mintz@qlogic.com>
Cc: Tariq Toukan <tariqt@mellanox.com>
Cc: Saeed Mahameed <saeedm@mellanox.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/Documentation/vm/transhuge.txt b/Documentation/vm/transhuge.txt
index d9cb65cf5cfdf786650f3d8345f6d6346f05f930..fb0e1f2a19cc1fbe860f1db3ddfeaeaa65c7b804 100644 (file)
--- a/Documentation/vm/transhuge.txt
+++ b/Documentation/vm/transhuge.txt
@@ -394,9 +394,9 @@ hugepage natively. Once finished you can drop the page table lock.
 Refcounting on THP is mostly consistent with refcounting on other compound
 pages:
 
-  - get_page()/put_page() and GUP operate in head page's ->_count.
+  - get_page()/put_page() and GUP operate in head page's ->_refcount.
 
-  - ->_count in tail pages is always zero: get_page_unless_zero() never
+  - ->_refcount in tail pages is always zero: get_page_unless_zero() never
     succeed on tail pages.
 
   - map/unmap of the pages with PTE entry increment/decrement ->_mapcount
@@ -426,15 +426,15 @@ requests to split pinned huge page: it expects page count to be equal to
 sum of mapcount of all sub-pages plus one (split_huge_page caller must
 have reference for head page).
 
-split_huge_page uses migration entries to stabilize page->_count and
+split_huge_page uses migration entries to stabilize page->_refcount and
 page->_mapcount.
 
 We safe against physical memory scanners too: the only legitimate way
 scanner can get reference to a page is get_page_unless_zero().
 
-All tail pages has zero ->_count until atomic_add(). It prevent scanner
+All tail pages has zero ->_refcount until atomic_add(). It prevent scanner
 from geting reference to tail page up to the point. After the atomic_add()
-we don't care about ->_count value.  We already known how many references
+we don't care about ->_refcount value.  We already known how many references
 with should uncharge from head page.
 
 For head page get_page_unless_zero() will succeed and we don't mind. It's

diff --git a/arch/tile/mm/init.c b/arch/tile/mm/init.c
index a0582b7f41d3357b4db0507df4a7153a028b0fe7..adce25462b0dbaf6bc8147583333b7ee1863b39d 100644 (file)
--- a/arch/tile/mm/init.c
+++ b/arch/tile/mm/init.c
@@ -679,7 +679,7 @@ static void __init init_free_pfn_range(unsigned long start, unsigned long end)
                         * Hacky direct set to avoid unnecessary
                         * lock take/release for EVERY page here.
                         */
-                       p->_count.counter = 0;
+                       p->_refcount.counter = 0;
                        p->_mapcount.counter = -1;
                }
                init_page_count(page);

diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index 437b3a822f4482c5a6e34a2c1f827f5560d1f56e..d597e432e195305906d357e113b90659cbdadbd6 100644 (file)
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -861,7 +861,7 @@ rqbiocnt(struct request *r)
  * discussion.
  *
  * We cannot use get_page in the workaround, because it insists on a
- * positive page count as a precondition.  So we use _count directly.
+ * positive page count as a precondition.  So we use _refcount directly.
  */
 static void
 bio_pageinc(struct bio *bio)

diff --git a/drivers/hwtracing/intel_th/msu.c b/drivers/hwtracing/intel_th/msu.c
index d9d6022c5aca42bbf959d214abb76b5ee3fe8704..d2209147dc8912ae590584a5a0890171239f9ad2 100644 (file)
--- a/drivers/hwtracing/intel_th/msu.c
+++ b/drivers/hwtracing/intel_th/msu.c
@@ -1164,7 +1164,7 @@ static void msc_mmap_close(struct vm_area_struct *vma)
        if (!atomic_dec_and_mutex_lock(&msc->mmap_count, &msc->buf_mutex))
                return;
 
-       /* drop page _counts */
+       /* drop page _refcounts */
        for (pg = 0; pg < msc->nr_pages; pg++) {
                struct page *page = msc_buffer_get_page(msc, pg);
 

diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
index f3456798c5960fda619a2a57074aa9aaf902e1ef..bd947704b59c41747a71d75725a5d230bde5dfc0 100644 (file)
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
@@ -433,8 +433,8 @@ static int mlx5e_alloc_rx_fragmented_mpwqe(struct mlx5e_rq *rq,
        for (i = 0; i < MLX5_MPWRQ_PAGES_PER_WQE; i++) {
                if (unlikely(mlx5e_alloc_and_map_page(rq, wi, i)))
                        goto err_unmap;
-               atomic_add(mlx5e_mpwqe_strides_per_page(rq),
-                          &wi->umr.dma_info[i].page->_count);
+               page_ref_add(wi->umr.dma_info[i].page,
+                            mlx5e_mpwqe_strides_per_page(rq));
                wi->skbs_frags[i] = 0;
        }
 
@@ -452,8 +452,8 @@ err_unmap:
        while (--i >= 0) {
                dma_unmap_page(rq->pdev, wi->umr.dma_info[i].addr, PAGE_SIZE,
                               PCI_DMA_FROMDEVICE);
-               atomic_sub(mlx5e_mpwqe_strides_per_page(rq),
-                          &wi->umr.dma_info[i].page->_count);
+               page_ref_sub(wi->umr.dma_info[i].page,
+                            mlx5e_mpwqe_strides_per_page(rq));
                put_page(wi->umr.dma_info[i].page);
        }
        dma_unmap_single(rq->pdev, wi->umr.mtt_addr, mtt_sz, PCI_DMA_TODEVICE);
@@ -477,8 +477,8 @@ void mlx5e_free_rx_fragmented_mpwqe(struct mlx5e_rq *rq,
        for (i = 0; i < MLX5_MPWRQ_PAGES_PER_WQE; i++) {
                dma_unmap_page(rq->pdev, wi->umr.dma_info[i].addr, PAGE_SIZE,
                               PCI_DMA_FROMDEVICE);
-               atomic_sub(mlx5e_mpwqe_strides_per_page(rq) - wi->skbs_frags[i],
-                          &wi->umr.dma_info[i].page->_count);
+               page_ref_sub(wi->umr.dma_info[i].page,
+                       mlx5e_mpwqe_strides_per_page(rq) - wi->skbs_frags[i]);
                put_page(wi->umr.dma_info[i].page);
        }
        dma_unmap_single(rq->pdev, wi->umr.mtt_addr, mtt_sz, PCI_DMA_TODEVICE);
@@ -527,8 +527,8 @@ static int mlx5e_alloc_rx_linear_mpwqe(struct mlx5e_rq *rq,
         */
        split_page(wi->dma_info.page, MLX5_MPWRQ_WQE_PAGE_ORDER);
        for (i = 0; i < MLX5_MPWRQ_PAGES_PER_WQE; i++) {
-               atomic_add(mlx5e_mpwqe_strides_per_page(rq),
-                          &wi->dma_info.page[i]._count);
+               page_ref_add(&wi->dma_info.page[i],
+                            mlx5e_mpwqe_strides_per_page(rq));
                wi->skbs_frags[i] = 0;
        }
 
@@ -551,8 +551,8 @@ void mlx5e_free_rx_linear_mpwqe(struct mlx5e_rq *rq,
        dma_unmap_page(rq->pdev, wi->dma_info.addr, rq->wqe_sz,
                       PCI_DMA_FROMDEVICE);
        for (i = 0; i < MLX5_MPWRQ_PAGES_PER_WQE; i++) {
-               atomic_sub(mlx5e_mpwqe_strides_per_page(rq) - wi->skbs_frags[i],
-                          &wi->dma_info.page[i]._count);
+               page_ref_sub(&wi->dma_info.page[i],
+                       mlx5e_mpwqe_strides_per_page(rq) - wi->skbs_frags[i]);
                put_page(&wi->dma_info.page[i]);
        }
 }

diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 3aabfc0adefe39863a3e7db08bf8a375a2bdd647..73dd525fbf08571e391c1fcacecceeeb0dd9dc42 100644 (file)
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -1036,7 +1036,7 @@ static int qede_fill_frag_skb(struct qede_dev *edev,
                /* Incr page ref count to reuse on allocation failure
                 * so that it doesn't get freed while freeing SKB.
                 */
-               atomic_inc(&current_bd->data->_count);
+               page_ref_inc(current_bd->data);
                goto out;
        }
 
@@ -1487,7 +1487,7 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                                 * freeing SKB.
                                 */
 
-                               atomic_inc(&sw_rx_data->data->_count);
+                               page_ref_inc(sw_rx_data->data);
                                rxq->rx_alloc_errors++;
                                qede_recycle_rx_bd_ring(rxq, edev,
                                                        fp_cqe->bd_num);

diff --git a/fs/proc/page.c b/fs/proc/page.c
index 712f1b9992ccba12deaeae38d3b4e7bcfb50297d..3ecd445e830dc6138916c5db984e05da9e91807c 100644 (file)
--- a/fs/proc/page.c
+++ b/fs/proc/page.c
@@ -142,7 +142,7 @@ u64 stable_page_flags(struct page *page)
 
 
        /*
-        * Caveats on high order pages: page->_count will only be set
+        * Caveats on high order pages: page->_refcount will only be set
         * -1 on the head page; SLUB/SLQB do the same for PG_slab;
         * SLOB won't set PG_slab at all on compound pages.
         */

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 727f799757abf411404937fcef6783356ea1c6cd..1193a54ea2b32160a4c895d32e6fb6b83711ac9f 100644 (file)
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -734,7 +734,7 @@ static inline void get_page(struct page *page)
        page = compound_head(page);
        /*
         * Getting a normal page or the head of a compound page
-        * requires to already have an elevated page->_count.
+        * requires to already have an elevated page->_refcount.
         */
        VM_BUG_ON_PAGE(page_ref_count(page) <= 0, page);
        page_ref_inc(page);

diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index c2d75b4fa86c05012a509dd188e2a394d2cb2170..1fda9c99ef956f3b1ce25dce253f48444511511c 100644 (file)
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -73,9 +73,9 @@ struct page {
                        unsigned long counters;
 #else
                        /*
-                        * Keep _count separate from slub cmpxchg_double data.
-                        * As the rest of the double word is protected by
-                        * slab_lock but _count is not.
+                        * Keep _refcount separate from slub cmpxchg_double
+                        * data.  As the rest of the double word is protected by
+                        * slab_lock but _refcount is not.
                         */
                        unsigned counters;
 #endif
@@ -97,7 +97,11 @@ struct page {
                                        };
                                        int units;      /* SLOB */
                                };
-                               atomic_t _count;                /* Usage count, see below. */
+                               /*
+                                * Usage count, *USE WRAPPER FUNCTION*
+                                * when manual accounting. See page_ref.h
+                                */
+                               atomic_t _refcount;
                        };
                        unsigned int active;    /* SLAB */
                };
@@ -248,7 +252,7 @@ struct page_frag_cache {
        __u32 offset;
 #endif
        /* we maintain a pagecount bias, so that we dont dirty cache line
-        * containing page->_count every time we allocate a fragment.
+        * containing page->_refcount every time we allocate a fragment.
         */
        unsigned int            pagecnt_bias;
        bool pfmemalloc;

diff --git a/include/linux/page_ref.h b/include/linux/page_ref.h
index e596d5d9540e2b534d6ad1fb09a1e1d68274fdf4..8b5e0a9f2431a7b833bdb836600fe512dfbe0651 100644 (file)
--- a/include/linux/page_ref.h
+++ b/include/linux/page_ref.h
@@ -63,17 +63,17 @@ static inline void __page_ref_unfreeze(struct page *page, int v)
 
 static inline int page_ref_count(struct page *page)
 {
-       return atomic_read(&page->_count);
+       return atomic_read(&page->_refcount);
 }
 
 static inline int page_count(struct page *page)
 {
-       return atomic_read(&compound_head(page)->_count);
+       return atomic_read(&compound_head(page)->_refcount);
 }
 
 static inline void set_page_count(struct page *page, int v)
 {
-       atomic_set(&page->_count, v);
+       atomic_set(&page->_refcount, v);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_set))
                __page_ref_set(page, v);
 }
@@ -89,35 +89,35 @@ static inline void init_page_count(struct page *page)
 
 static inline void page_ref_add(struct page *page, int nr)
 {
-       atomic_add(nr, &page->_count);
+       atomic_add(nr, &page->_refcount);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod))
                __page_ref_mod(page, nr);
 }
 
 static inline void page_ref_sub(struct page *page, int nr)
 {
-       atomic_sub(nr, &page->_count);
+       atomic_sub(nr, &page->_refcount);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod))
                __page_ref_mod(page, -nr);
 }
 
 static inline void page_ref_inc(struct page *page)
 {
-       atomic_inc(&page->_count);
+       atomic_inc(&page->_refcount);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod))
                __page_ref_mod(page, 1);
 }
 
 static inline void page_ref_dec(struct page *page)
 {
-       atomic_dec(&page->_count);
+       atomic_dec(&page->_refcount);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod))
                __page_ref_mod(page, -1);
 }
 
 static inline int page_ref_sub_and_test(struct page *page, int nr)
 {
-       int ret = atomic_sub_and_test(nr, &page->_count);
+       int ret = atomic_sub_and_test(nr, &page->_refcount);
 
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod_and_test))
                __page_ref_mod_and_test(page, -nr, ret);
@@ -126,7 +126,7 @@ static inline int page_ref_sub_and_test(struct page *page, int nr)
 
 static inline int page_ref_dec_and_test(struct page *page)
 {
-       int ret = atomic_dec_and_test(&page->_count);
+       int ret = atomic_dec_and_test(&page->_refcount);
 
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod_and_test))
                __page_ref_mod_and_test(page, -1, ret);
@@ -135,7 +135,7 @@ static inline int page_ref_dec_and_test(struct page *page)
 
 static inline int page_ref_dec_return(struct page *page)
 {
-       int ret = atomic_dec_return(&page->_count);
+       int ret = atomic_dec_return(&page->_refcount);
 
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod_and_return))
                __page_ref_mod_and_return(page, -1, ret);
@@ -144,7 +144,7 @@ static inline int page_ref_dec_return(struct page *page)
 
 static inline int page_ref_add_unless(struct page *page, int nr, int u)
 {
-       int ret = atomic_add_unless(&page->_count, nr, u);
+       int ret = atomic_add_unless(&page->_refcount, nr, u);
 
        if (page_ref_tracepoint_active(__tracepoint_page_ref_mod_unless))
                __page_ref_mod_unless(page, nr, ret);
@@ -153,7 +153,7 @@ static inline int page_ref_add_unless(struct page *page, int nr, int u)
 
 static inline int page_ref_freeze(struct page *page, int count)
 {
-       int ret = likely(atomic_cmpxchg(&page->_count, count, 0) == count);
+       int ret = likely(atomic_cmpxchg(&page->_refcount, count, 0) == count);
 
        if (page_ref_tracepoint_active(__tracepoint_page_ref_freeze))
                __page_ref_freeze(page, count, ret);
@@ -165,7 +165,7 @@ static inline void page_ref_unfreeze(struct page *page, int count)
        VM_BUG_ON_PAGE(page_count(page) != 0, page);
        VM_BUG_ON(count == 0);
 
-       atomic_set(&page->_count, count);
+       atomic_set(&page->_refcount, count);
        if (page_ref_tracepoint_active(__tracepoint_page_ref_unfreeze))
                __page_ref_unfreeze(page, count);
 }

diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 7e1ab155c67c78dd6e41defebd238bce0d59af7f..fe1513ffb7bf5ca21c004c0eb654f1c23433d955 100644 (file)
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -90,12 +90,12 @@ void release_pages(struct page **pages, int nr, bool cold);
 
 /*
  * speculatively take a reference to a page.
- * If the page is free (_count == 0), then _count is untouched, and 0
- * is returned. Otherwise, _count is incremented by 1 and 1 is returned.
+ * If the page is free (_refcount == 0), then _refcount is untouched, and 0
+ * is returned. Otherwise, _refcount is incremented by 1 and 1 is returned.
  *
  * This function must be called inside the same rcu_read_lock() section as has
  * been used to lookup the page in the pagecache radix-tree (or page table):
- * this allows allocators to use a synchronize_rcu() to stabilize _count.
+ * this allows allocators to use a synchronize_rcu() to stabilize _refcount.
  *
  * Unless an RCU grace period has passed, the count of all pages coming out
  * of the allocator must be considered unstable. page_count may return higher
@@ -111,7 +111,7 @@ void release_pages(struct page **pages, int nr, bool cold);
  * 2. conditionally increment refcount
  * 3. check the page is still in pagecache (if no, goto 1)
  *
- * Remove-side that cares about stability of _count (eg. reclaim) has the
+ * Remove-side that cares about stability of _refcount (eg. reclaim) has the
  * following (with tree_lock held for write):
  * A. atomically check refcount is correct and set it to 0 (atomic_cmpxchg)
  * B. remove page from pagecache

diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
index 1391d3ee3b8666c07b677ffd35a5fd2f2b2882d7..1c03dfb4abfd31fa2d15fbd74c1c3e11794e3920 100644 (file)
--- a/kernel/kexec_core.c
+++ b/kernel/kexec_core.c
@@ -1410,7 +1410,7 @@ static int __init crash_save_vmcoreinfo_init(void)
        VMCOREINFO_STRUCT_SIZE(list_head);
        VMCOREINFO_SIZE(nodemask_t);
        VMCOREINFO_OFFSET(page, flags);
-       VMCOREINFO_OFFSET(page, _count);
+       VMCOREINFO_OFFSET(page, _refcount);
        VMCOREINFO_OFFSET(page, mapping);
        VMCOREINFO_OFFSET(page, lru);
        VMCOREINFO_OFFSET(page, _mapcount);

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index b49ee126d4d1feb7a89a9c776edc89141c3351da..f8ac8f582fd8e0de43fc7a0ee8c66106bbbf6f48 100644 (file)
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -3113,7 +3113,7 @@ static void __split_huge_page_tail(struct page *head, int tail,
        VM_BUG_ON_PAGE(page_ref_count(page_tail) != 0, page_tail);
 
        /*
-        * tail_page->_count is zero and not changing from under us. But
+        * tail_page->_refcount is zero and not changing from under us. But
         * get_page_unless_zero() may be running from under us on the
         * tail_page. If we used atomic_set() below instead of atomic_inc(), we
         * would then run atomic_set() concurrently with
@@ -3340,7 +3340,7 @@ int split_huge_page_to_list(struct page *page, struct list_head *list)
        if (mlocked)
                lru_add_drain();
 
-       /* Prevent deferred_split_scan() touching ->_count */
+       /* Prevent deferred_split_scan() touching ->_refcount */
        spin_lock_irqsave(&pgdata->split_queue_lock, flags);
        count = page_count(head);
        mapcount = total_mapcount(head);

diff --git a/mm/internal.h b/mm/internal.h
index b79abb6721cf79ac0b6a626e94fa4856c6e515a6..098a89e3b97c90663c8127e2433d7dcad37487e5 100644 (file)
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -58,7 +58,7 @@ static inline unsigned long ra_submit(struct file_ra_state *ra,
 }
 
 /*
- * Turn a non-refcounted page (->_count == 0) into refcounted with
+ * Turn a non-refcounted page (->_refcount == 0) into refcounted with
  * a count of one.
  */
 static inline void set_page_refcounted(struct page *page)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index c1069efcc4d7477a5fc517303b67747f89b77074..4ce57f938b7f8efc0e1cdf62bf4e1bf2cc451420 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -794,7 +794,7 @@ static inline int free_pages_check(struct page *page)
        if (unlikely(page->mapping != NULL))
                bad_reason = "non-NULL mapping";
        if (unlikely(page_ref_count(page) != 0))
-               bad_reason = "nonzero _count";
+               bad_reason = "nonzero _refcount";
        if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_FREE)) {
                bad_reason = "PAGE_FLAGS_CHECK_AT_FREE flag(s) set";
                bad_flags = PAGE_FLAGS_CHECK_AT_FREE;
@@ -6864,7 +6864,7 @@ bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
                 * We can't use page_count without pin a page
                 * because another CPU can free compound page.
                 * This check already skips compound tails of THP
-                * because their page->_count is zero at all time.
+                * because their page->_refcount is zero at all time.
                 */
                if (!page_ref_count(page)) {
                        if (PageBuddy(page))

diff --git a/mm/slub.c b/mm/slub.c
index 8671de2e5b12874f406ad911b8a3ac1f46ee2751..cf1faa4d3992520ead5dd61deed5e7c41ef9175a 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -329,8 +329,8 @@ static inline void set_page_slub_counters(struct page *page, unsigned long count
        tmp.counters = counters_new;
        /*
         * page->counters can cover frozen/inuse/objects as well
-        * as page->_count.  If we assign to ->counters directly
-        * we run the risk of losing updates to page->_count, so
+        * as page->_refcount.  If we assign to ->counters directly
+        * we run the risk of losing updates to page->_refcount, so
         * be careful and only assign to the fields we need.
         */
        page->frozen  = tmp.frozen;

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 142cb61f4822454bf3819a4c10c4e8b479a70ec8..d3a02ac3eed7df63e6bfb0325e1414ed5e2353fd 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -633,7 +633,7 @@ static int __remove_mapping(struct address_space *mapping, struct page *page,
         *
         * Reversing the order of the tests ensures such a situation cannot
         * escape unnoticed. The smp_rmb is needed to ensure the page->flags
-        * load is not satisfied before that of page->_count.
+        * load is not satisfied before that of page->_refcount.
         *
         * Note that if SetPageDirty is always performed via set_page_dirty,
         * and thus under tree_lock, then this ordering is not required.
@@ -1720,7 +1720,7 @@ shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
  * It is safe to rely on PG_active against the non-LRU pages in here because
  * nobody will play with that bit on a non-LRU page.
  *
- * The downside is that we have to touch page->_count against each page.
+ * The downside is that we have to touch page->_refcount against each page.
  * But we had to alter page->flags anyway.
  */