percpu-refcount: sparse fixes

Here's some more fixes, the percpu refcount code is now sparse clean for
me.  It's kind of ugly, but I'm not sure it's really any uglier than it
was before.  Seem reasonable?

Signed-off-by: Kent Overstreet <koverstreet@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index 1268010afd54f043dfa7833cb293503babe3419d..922860474f0014dd401afc95c58d330b0db351ae 100644 (file)
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -6,7 +6,7 @@
 
 struct percpu_ref {
        atomic64_t              count;
-       unsigned __percpu       *pcpu_count;
+       unsigned long           pcpu_count;
 };
 
 void percpu_ref_init(struct percpu_ref *ref);

diff --git a/lib/percpu-refcount.c b/lib/percpu-refcount.c
index e2d8d1250c74d53c007db81937329896cef4067b..a2783687e086e422d45e85469eb1191245312a53 100644 (file)
--- a/lib/percpu-refcount.c
+++ b/lib/percpu-refcount.c
@@ -16,7 +16,7 @@
 #define PCPU_REF_DYING         2
 #define PCPU_REF_DEAD          3
 
-#define REF_STATUS(count)      ((unsigned long) count & PCPU_STATUS_MASK)
+#define REF_STATUS(count)      (count & PCPU_STATUS_MASK)
 
 void percpu_ref_init(struct percpu_ref *ref)
 {
@@ -27,47 +27,47 @@ void percpu_ref_init(struct percpu_ref *ref)
        now <<= PCPU_STATUS_BITS;
        now |= PCPU_REF_NONE;
 
-       ref->pcpu_count = (void *) now;
+       ref->pcpu_count = now;
 }
 
-static void percpu_ref_alloc(struct percpu_ref *ref, unsigned __user *pcpu_count)
+static void percpu_ref_alloc(struct percpu_ref *ref, unsigned long pcpu_count)
 {
-       unsigned __percpu *new;
-       unsigned long last = (unsigned long) pcpu_count;
-       unsigned long now = jiffies;
+       unsigned long new, now = jiffies;
 
        now <<= PCPU_STATUS_BITS;
        now |= PCPU_REF_NONE;
 
-       if (now - last <= HZ << PCPU_STATUS_BITS) {
+       if (now - pcpu_count <= HZ << PCPU_STATUS_BITS) {
                rcu_read_unlock();
-               new = alloc_percpu(unsigned);
+               new = (unsigned long) alloc_percpu(unsigned);
                rcu_read_lock();
 
                if (!new)
                        goto update_time;
 
-               BUG_ON(((unsigned long) new) & PCPU_STATUS_MASK);
+               BUG_ON(new & PCPU_STATUS_MASK);
 
                if (cmpxchg(&ref->pcpu_count, pcpu_count, new) != pcpu_count)
-                       free_percpu(new);
+                       free_percpu((void __percpu *) new);
                else
                        pr_debug("created");
        } else {
-update_time:   new = (void *) now;
+update_time:   new = now;
                cmpxchg(&ref->pcpu_count, pcpu_count, new);
        }
 }
 
 void __percpu_ref_get(struct percpu_ref *ref, bool alloc)
 {
-       unsigned __percpu *pcpu_count;
+       unsigned long pcpu_count;
        uint64_t v;
 
-       pcpu_count = rcu_dereference(ref->pcpu_count);
+       pcpu_count = ACCESS_ONCE(ref->pcpu_count);
 
        if (REF_STATUS(pcpu_count) == PCPU_REF_PTR) {
-               __this_cpu_inc(*pcpu_count);
+               /* for rcu - we're not using rcu_dereference() */
+               smp_read_barrier_depends();
+               __this_cpu_inc(*((unsigned __percpu *) pcpu_count));
        } else {
                v = atomic64_add_return(1 + (1ULL << PCPU_COUNT_BITS),
                                        &ref->count);
@@ -80,17 +80,19 @@ void __percpu_ref_get(struct percpu_ref *ref, bool alloc)
 
 int percpu_ref_put(struct percpu_ref *ref)
 {
-       unsigned __percpu *pcpu_count;
+       unsigned long pcpu_count;
        uint64_t v;
        int ret = 0;
 
        rcu_read_lock();
 
-       pcpu_count = rcu_dereference(ref->pcpu_count);
+       pcpu_count = ACCESS_ONCE(ref->pcpu_count);
 
        switch (REF_STATUS(pcpu_count)) {
        case PCPU_REF_PTR:
-               __this_cpu_dec(*pcpu_count);
+               /* for rcu - we're not using rcu_dereference() */
+               smp_read_barrier_depends();
+               __this_cpu_dec(*((unsigned __percpu *) pcpu_count));
                break;
        case PCPU_REF_NONE:
        case PCPU_REF_DYING:
@@ -111,18 +113,19 @@ int percpu_ref_put(struct percpu_ref *ref)
 
 int percpu_ref_kill(struct percpu_ref *ref)
 {
-       unsigned __percpu *old, *new, *pcpu_count = ref->pcpu_count;
-       unsigned long status;
+       unsigned long old, new, status, pcpu_count;
+
+       pcpu_count = ACCESS_ONCE(ref->pcpu_count);
 
        do {
                status = REF_STATUS(pcpu_count);
 
                switch (status) {
                case PCPU_REF_PTR:
-                       new = (void *) PCPU_REF_DYING;
+                       new = PCPU_REF_DYING;
                        break;
                case PCPU_REF_NONE:
-                       new = (void *) PCPU_REF_DEAD;
+                       new = PCPU_REF_DEAD;
                        break;
                case PCPU_REF_DYING:
                case PCPU_REF_DEAD:
@@ -139,7 +142,7 @@ int percpu_ref_kill(struct percpu_ref *ref)
                synchronize_rcu();
 
                for_each_possible_cpu(cpu)
-                       count += *per_cpu_ptr(pcpu_count, cpu);
+                       count += *per_cpu_ptr((unsigned __percpu *) pcpu_count, cpu);
 
                pr_debug("global %lli pcpu %i",
                         atomic64_read(&ref->count) & PCPU_COUNT_MASK,
@@ -148,9 +151,9 @@ int percpu_ref_kill(struct percpu_ref *ref)
                atomic64_add((int) count, &ref->count);
                smp_wmb();
                /* Between setting global count and setting PCPU_REF_DEAD */
-               ref->pcpu_count = (void *) PCPU_REF_DEAD;
+               ref->pcpu_count = PCPU_REF_DEAD;
 
-               free_percpu(pcpu_count);
+               free_percpu((unsigned __percpu *) pcpu_count);
        }
 
        return 1;