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>

1 files changed, 13 insertions, 13 deletions

diff --git a/include/linux/page_ref.h b/include/linux/page_ref.h
index e596d5d9540e..8b5e0a9f2431 100644
--- 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);
 }