mm: rename page_counter's count/limit into usage/max

[linux.git] / mm / page_counter.c

diff --git a/mm/page_counter.c b/mm/page_counter.c
index 2a8df3ad60a4ecce1b4e4839f1b42033ad759a25..41937c9a9d11df8aff94d0f94e3e9d7da312b3a5 100644 (file)
--- a/mm/page_counter.c
+++ b/mm/page_counter.c
@@ -22,7 +22,7 @@ void page_counter_cancel(struct page_counter *counter, unsigned long nr_pages)
 {
        long new;
 
-       new = atomic_long_sub_return(nr_pages, &counter->count);
+       new = atomic_long_sub_return(nr_pages, &counter->usage);
        /* More uncharges than charges? */
        WARN_ON_ONCE(new < 0);
 }
@@ -41,7 +41,7 @@ void page_counter_charge(struct page_counter *counter, unsigned long nr_pages)
        for (c = counter; c; c = c->parent) {
                long new;
 
-               new = atomic_long_add_return(nr_pages, &c->count);
+               new = atomic_long_add_return(nr_pages, &c->usage);
                /*
                 * This is indeed racy, but we can live with some
                 * inaccuracy in the watermark.
@@ -82,9 +82,9 @@ bool page_counter_try_charge(struct page_counter *counter,
                 * we either see the new limit or the setter sees the
                 * counter has changed and retries.
                 */
-               new = atomic_long_add_return(nr_pages, &c->count);
-               if (new > c->limit) {
-                       atomic_long_sub(nr_pages, &c->count);
+               new = atomic_long_add_return(nr_pages, &c->usage);
+               if (new > c->max) {
+                       atomic_long_sub(nr_pages, &c->usage);
                        /*
                         * This is racy, but we can live with some
                         * inaccuracy in the failcnt.
@@ -123,20 +123,20 @@ void page_counter_uncharge(struct page_counter *counter, unsigned long nr_pages)
 }
 
 /**
- * page_counter_limit - limit the number of pages allowed
+ * page_counter_set_max - set the maximum number of pages allowed
  * @counter: counter
- * @limit: limit to set
+ * @nr_pages: limit to set
  *
  * Returns 0 on success, -EBUSY if the current number of pages on the
  * counter already exceeds the specified limit.
  *
  * The caller must serialize invocations on the same counter.
  */
-int page_counter_limit(struct page_counter *counter, unsigned long limit)
+int page_counter_set_max(struct page_counter *counter, unsigned long nr_pages)
 {
        for (;;) {
                unsigned long old;
-               long count;
+               long usage;
 
                /*
                 * Update the limit while making sure that it's not
@@ -149,17 +149,17 @@ int page_counter_limit(struct page_counter *counter, unsigned long limit)
                 * the limit, so if it sees the old limit, we see the
                 * modified counter and retry.
                 */
-               count = atomic_long_read(&counter->count);
+               usage = atomic_long_read(&counter->usage);
 
-               if (count > limit)
+               if (usage > nr_pages)
                        return -EBUSY;
 
-               old = xchg(&counter->limit, limit);
+               old = xchg(&counter->max, nr_pages);
 
-               if (atomic_long_read(&counter->count) <= count)
+               if (atomic_long_read(&counter->usage) <= usage)
                        return 0;
 
-               counter->limit = old;
+               counter->max = old;
                cond_resched();
        }
 }