Merge branch 'for-3.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu

Pull percpu updates from Tejun Heo: "A lot of activities on percpu front. Notable changes are... - percpu allocator now can take @gfp. If @gfp doesn't contain GFP_KERNEL, it tries to allocate from what's already available to the allocator and a work item tries to keep the reserve around certain level so that these atomic allocations usually succeed. This will replace the ad-hoc percpu memory pool used by blk-throttle and also be used by the planned blkcg support for writeback IOs. Please note that I noticed a bug in how @gfp is interpreted while preparing this pull request and applied the fix 6ae833c7fe0c ("percpu: fix how @gfp is interpreted by the percpu allocator") just now. - percpu_ref now uses longs for percpu and global counters instead of ints. It leads to more sparse packing of the percpu counters on 64bit machines but the overhead should be negligible and this allows using percpu_ref for refcnting pages and in-memory objects directly. - The switching between percpu and single counter modes of a percpu_ref is made independent of putting the base ref and a percpu_ref can now optionally be initialized in single or killed mode. This allows avoiding percpu shutdown latency for cases where the refcounted objects may be synchronously created and destroyed in rapid succession with only a fraction of them reaching fully operational status (SCSI probing does this when combined with blk-mq support). It's also planned to be used to implement forced single mode to detect underflow more timely for debugging. There's a separate branch percpu/for-3.18-consistent-ops which cleans up the duplicate percpu accessors. That branch causes a number of conflicts with s390 and other trees. I'll send a separate pull request w/ resolutions once other branches are merged" * 'for-3.18' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu: (33 commits) percpu: fix how @gfp is interpreted by the percpu allocator blk-mq, percpu_ref: start q->mq_usage_counter in atomic mode percpu_ref: make INIT_ATOMIC and switch_to_atomic() sticky percpu_ref: add PERCPU_REF_INIT_* flags percpu_ref: decouple switching to percpu mode and reinit percpu_ref: decouple switching to atomic mode and killing percpu_ref: add PCPU_REF_DEAD percpu_ref: rename things to prepare for decoupling percpu/atomic mode switch percpu_ref: replace pcpu_ prefix with percpu_ percpu_ref: minor code and comment updates percpu_ref: relocate percpu_ref_reinit() Revert "blk-mq, percpu_ref: implement a kludge for SCSI blk-mq stall during probe" Revert "percpu: free percpu allocation info for uniprocessor system" percpu-refcount: make percpu_ref based on longs instead of ints percpu-refcount: improve WARN messages percpu: fix locking regression in the failure path of pcpu_alloc() percpu-refcount: add @gfp to percpu_ref_init() proportions: add @gfp to init functions percpu_counter: add @gfp to percpu_counter_init() percpu_counter: make percpu_counters_lock irq-safe ...
author: Linus Torvalds <torvalds@linux-foundation.org> 2014-10-10 07:26:02 -0400
committer: Linus Torvalds <torvalds@linux-foundation.org> 2014-10-10 07:26:02 -0400
commit: c798360cd1438090d51eeaa8e67985da11362eba (patch)
tree: 0107d3b9ee7476264c3357287787d393545bd2d9 /lib
parent: b211e9d7c861bdb37b86d6384da9edfb80949ceb (diff)
parent: 6ae833c7fe0c6ef1f0ab13cc775da230d6f4c256 (diff)
4 files changed, 238 insertions, 105 deletions
diff --git a/lib/flex_proportions.c b/lib/flex_proportions.c
index ebf3bac460b0..8f25652f40d4 100644
--- a/lib/flex_proportions.c
+++ b/lib/flex_proportions.c
@@ -34,13 +34,13 @@
 */
 #include <linux/flex_proportions.h>
-int fprop_global_init(struct fprop_global *p)
+int fprop_global_init(struct fprop_global *p, gfp_t gfp)
 {
        int err;
        p->period = 0;
        /* Use 1 to avoid dealing with periods with 0 events... */
-        err = percpu_counter_init(&p->events, 1);
+        err = percpu_counter_init(&p->events, 1, gfp);
        if (err)
                return err;
        seqcount_init(&p->sequence);
@@ -168,11 +168,11 @@ void fprop_fraction_single(struct fprop_global *p,
 */
 #define PROP_BATCH (8*(1+ilog2(nr_cpu_ids)))
-int fprop_local_init_percpu(struct fprop_local_percpu *pl)
+int fprop_local_init_percpu(struct fprop_local_percpu *pl, gfp_t gfp)
 {
        int err;
-        err = percpu_counter_init(&pl->events, 0);
+        err = percpu_counter_init(&pl->events, 0, gfp);
        if (err)
                return err;
        pl->period = 0;
diff --git a/lib/percpu-refcount.c b/lib/percpu-refcount.c
index a89cf09a8268..6111bcb28376 100644
--- a/lib/percpu-refcount.c
+++ b/lib/percpu-refcount.c
@@ -1,6 +1,8 @@
 #define pr_fmt(fmt) "%s: " fmt "\n", __func__
 #include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
 #include <linux/percpu-refcount.h>
 /*
@@ -11,8 +13,8 @@
 * percpu counters will all sum to the correct value
 *
 * (More precisely: because moduler arithmatic is commutative the sum of all the
- * pcpu_count vars will be equal to what it would have been if all the gets and
+ * percpu_count vars will be equal to what it would have been if all the gets
- * puts were done to a single integer, even if some of the percpu integers
+ * and puts were done to a single integer, even if some of the percpu integers
 * overflow or underflow).
 *
 * The real trick to implementing percpu refcounts is shutdown. We can't detect
@@ -25,75 +27,64 @@
 * works.
 *
 * Converting to non percpu mode is done with some RCUish stuff in
- * percpu_ref_kill. Additionally, we need a bias value so that the atomic_t
+ * percpu_ref_kill. Additionally, we need a bias value so that the
- * can't hit 0 before we've added up all the percpu refs.
+ * atomic_long_t can't hit 0 before we've added up all the percpu refs.
 */
-#define PCPU_COUNT_BIAS         (1U << 31)
+#define PERCPU_COUNT_BIAS       (1LU << (BITS_PER_LONG - 1))
-static unsigned __percpu *pcpu_count_ptr(struct percpu_ref *ref)
+static DECLARE_WAIT_QUEUE_HEAD(percpu_ref_switch_waitq);
+static unsigned long __percpu *percpu_count_ptr(struct percpu_ref *ref)
 {
-        return (unsigned __percpu *)(ref->pcpu_count_ptr & ~PCPU_REF_DEAD);
+        return (unsigned long __percpu *)
+                (ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC_DEAD);
 }
 /**
 * percpu_ref_init - initialize a percpu refcount
 * @ref: percpu_ref to initialize
 * @release: function which will be called when refcount hits 0
+ * @flags: PERCPU_REF_INIT_* flags
+ * @gfp: allocation mask to use
 *
- * Initializes the refcount in single atomic counter mode with a refcount of 1;
+ * Initializes @ref.  If @flags is zero, @ref starts in percpu mode with a
- * analagous to atomic_set(ref, 1).
+ * refcount of 1; analagous to atomic_long_set(ref, 1).  See the
+ * definitions of PERCPU_REF_INIT_* flags for flag behaviors.
 *
 * Note that @release must not sleep - it may potentially be called from RCU
 * callback context by percpu_ref_kill().
 */
-int percpu_ref_init(struct percpu_ref *ref, percpu_ref_func_t *release)
+int percpu_ref_init(struct percpu_ref *ref, percpu_ref_func_t *release,
+                    unsigned int flags, gfp_t gfp)
 {
-        atomic_set(&ref->count, 1 + PCPU_COUNT_BIAS);
+        size_t align = max_t(size_t, 1 << __PERCPU_REF_FLAG_BITS,
+                             __alignof__(unsigned long));
+        unsigned long start_count = 0;
-        ref->pcpu_count_ptr = (unsigned long)alloc_percpu(unsigned);
+        ref->percpu_count_ptr = (unsigned long)
-        if (!ref->pcpu_count_ptr)
+                __alloc_percpu_gfp(sizeof(unsigned long), align, gfp);
+        if (!ref->percpu_count_ptr)
                return -ENOMEM;
-        ref->release = release;
+        ref->force_atomic = flags & PERCPU_REF_INIT_ATOMIC;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(percpu_ref_init);
-/**
- * percpu_ref_reinit - re-initialize a percpu refcount
- * @ref: perpcu_ref to re-initialize
- *
- * Re-initialize @ref so that it's in the same state as when it finished
- * percpu_ref_init().  @ref must have been initialized successfully, killed
- * and reached 0 but not exited.
- *
- * Note that percpu_ref_tryget[_live]() are safe to perform on @ref while
- * this function is in progress.
- */
-void percpu_ref_reinit(struct percpu_ref *ref)
-{
-        unsigned __percpu *pcpu_count = pcpu_count_ptr(ref);
-        int cpu;
-        BUG_ON(!pcpu_count);
+        if (flags & (PERCPU_REF_INIT_ATOMIC | PERCPU_REF_INIT_DEAD))
-        WARN_ON(!percpu_ref_is_zero(ref));
+                ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC;
+        else
+                start_count += PERCPU_COUNT_BIAS;
-        atomic_set(&ref->count, 1 + PCPU_COUNT_BIAS);
+        if (flags & PERCPU_REF_INIT_DEAD)
+                ref->percpu_count_ptr |= __PERCPU_REF_DEAD;
+        else
+                start_count++;
-        /*
+        atomic_long_set(&ref->count, start_count);
-         * Restore per-cpu operation.  smp_store_release() is paired with
-         * smp_read_barrier_depends() in __pcpu_ref_alive() and guarantees
-         * that the zeroing is visible to all percpu accesses which can see
-         * the following PCPU_REF_DEAD clearing.
-         */
-        for_each_possible_cpu(cpu)
-                *per_cpu_ptr(pcpu_count, cpu) = 0;
-        smp_store_release(&ref->pcpu_count_ptr,
+        ref->release = release;
-                          ref->pcpu_count_ptr & ~PCPU_REF_DEAD);
+        return 0;
 }
-EXPORT_SYMBOL_GPL(percpu_ref_reinit);
+EXPORT_SYMBOL_GPL(percpu_ref_init);
 /**
 * percpu_ref_exit - undo percpu_ref_init()
@@ -107,26 +98,39 @@ EXPORT_SYMBOL_GPL(percpu_ref_reinit);
 */
 void percpu_ref_exit(struct percpu_ref *ref)
 {
-        unsigned __percpu *pcpu_count = pcpu_count_ptr(ref);
+        unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
-        if (pcpu_count) {
+        if (percpu_count) {
-                free_percpu(pcpu_count);
+                free_percpu(percpu_count);
-                ref->pcpu_count_ptr = PCPU_REF_DEAD;
+                ref->percpu_count_ptr = __PERCPU_REF_ATOMIC_DEAD;
        }
 }
 EXPORT_SYMBOL_GPL(percpu_ref_exit);
-static void percpu_ref_kill_rcu(struct rcu_head *rcu)
+static void percpu_ref_call_confirm_rcu(struct rcu_head *rcu)
+{
+        struct percpu_ref *ref = container_of(rcu, struct percpu_ref, rcu);
+        ref->confirm_switch(ref);
+        ref->confirm_switch = NULL;
+        wake_up_all(&percpu_ref_switch_waitq);
+        /* drop ref from percpu_ref_switch_to_atomic() */
+        percpu_ref_put(ref);
+}
+static void percpu_ref_switch_to_atomic_rcu(struct rcu_head *rcu)
 {
        struct percpu_ref *ref = container_of(rcu, struct percpu_ref, rcu);
-        unsigned __percpu *pcpu_count = pcpu_count_ptr(ref);
+        unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
-        unsigned count = 0;
+        unsigned long count = 0;
        int cpu;
        for_each_possible_cpu(cpu)
-                count += *per_cpu_ptr(pcpu_count, cpu);
+                count += *per_cpu_ptr(percpu_count, cpu);
-        pr_debug("global %i pcpu %i", atomic_read(&ref->count), (int) count);
+        pr_debug("global %ld percpu %ld",
+                 atomic_long_read(&ref->count), (long)count);
        /*
         * It's crucial that we sum the percpu counters _before_ adding the sum
@@ -140,21 +144,137 @@ static void percpu_ref_kill_rcu(struct rcu_head *rcu)
         * reaching 0 before we add the percpu counts. But doing it at the same
         * time is equivalent and saves us atomic operations:
         */
+        atomic_long_add((long)count - PERCPU_COUNT_BIAS, &ref->count);
+        WARN_ONCE(atomic_long_read(&ref->count) <= 0,
+                  "percpu ref (%pf) <= 0 (%ld) after switching to atomic",
+                  ref->release, atomic_long_read(&ref->count));
+        /* @ref is viewed as dead on all CPUs, send out switch confirmation */
+        percpu_ref_call_confirm_rcu(rcu);
+}
+static void percpu_ref_noop_confirm_switch(struct percpu_ref *ref)
+{
+}
+static void __percpu_ref_switch_to_atomic(struct percpu_ref *ref,
+                                          percpu_ref_func_t *confirm_switch)
+{
+        if (!(ref->percpu_count_ptr & __PERCPU_REF_ATOMIC)) {
+                /* switching from percpu to atomic */
+                ref->percpu_count_ptr |= __PERCPU_REF_ATOMIC;
+                /*
+                 * Non-NULL ->confirm_switch is used to indicate that
+                 * switching is in progress.  Use noop one if unspecified.
+                 */
+                WARN_ON_ONCE(ref->confirm_switch);
+                ref->confirm_switch =
+                        confirm_switch ?: percpu_ref_noop_confirm_switch;
+                percpu_ref_get(ref);    /* put after confirmation */
+                call_rcu_sched(&ref->rcu, percpu_ref_switch_to_atomic_rcu);
+        } else if (confirm_switch) {
+                /*
+                 * Somebody already set ATOMIC.  Switching may still be in
+                 * progress.  @confirm_switch must be invoked after the
+                 * switching is complete and a full sched RCU grace period
+                 * has passed.  Wait synchronously for the previous
+                 * switching and schedule @confirm_switch invocation.
+                 */
+                wait_event(percpu_ref_switch_waitq, !ref->confirm_switch);
+                ref->confirm_switch = confirm_switch;
-        atomic_add((int) count - PCPU_COUNT_BIAS, &ref->count);
+                percpu_ref_get(ref);    /* put after confirmation */
+                call_rcu_sched(&ref->rcu, percpu_ref_call_confirm_rcu);
+        }
+}
+/**
+ * percpu_ref_switch_to_atomic - switch a percpu_ref to atomic mode
+ * @ref: percpu_ref to switch to atomic mode
+ * @confirm_switch: optional confirmation callback
+ *
+ * There's no reason to use this function for the usual reference counting.
+ * Use percpu_ref_kill[_and_confirm]().
+ *
+ * Schedule switching of @ref to atomic mode.  All its percpu counts will
+ * be collected to the main atomic counter.  On completion, when all CPUs
+ * are guaraneed to be in atomic mode, @confirm_switch, which may not
+ * block, is invoked.  This function may be invoked concurrently with all
+ * the get/put operations and can safely be mixed with kill and reinit
+ * operations.  Note that @ref will stay in atomic mode across kill/reinit
+ * cycles until percpu_ref_switch_to_percpu() is called.
+ *
+ * This function normally doesn't block and can be called from any context
+ * but it may block if @confirm_kill is specified and @ref is already in
+ * the process of switching to atomic mode.  In such cases, @confirm_switch
+ * will be invoked after the switching is complete.
+ *
+ * Due to the way percpu_ref is implemented, @confirm_switch will be called
+ * after at least one full sched RCU grace period has passed but this is an
+ * implementation detail and must not be depended upon.
+ */
+void percpu_ref_switch_to_atomic(struct percpu_ref *ref,
+                                 percpu_ref_func_t *confirm_switch)
+{
+        ref->force_atomic = true;
+        __percpu_ref_switch_to_atomic(ref, confirm_switch);
+}
-        WARN_ONCE(atomic_read(&ref->count) <= 0, "percpu ref <= 0 (%i)",
+static void __percpu_ref_switch_to_percpu(struct percpu_ref *ref)
-                  atomic_read(&ref->count));
+{
+        unsigned long __percpu *percpu_count = percpu_count_ptr(ref);
+        int cpu;
+        BUG_ON(!percpu_count);
-        /* @ref is viewed as dead on all CPUs, send out kill confirmation */
+        if (!(ref->percpu_count_ptr & __PERCPU_REF_ATOMIC))
-        if (ref->confirm_kill)
+                return;
-                ref->confirm_kill(ref);
+        wait_event(percpu_ref_switch_waitq, !ref->confirm_switch);
+        atomic_long_add(PERCPU_COUNT_BIAS, &ref->count);
        /*
-         * Now we're in single atomic_t mode with a consistent refcount, so it's
+         * Restore per-cpu operation.  smp_store_release() is paired with
-         * safe to drop our initial ref:
+         * smp_read_barrier_depends() in __ref_is_percpu() and guarantees
+         * that the zeroing is visible to all percpu accesses which can see
+         * the following __PERCPU_REF_ATOMIC clearing.
         */
-        percpu_ref_put(ref);
+        for_each_possible_cpu(cpu)
+                *per_cpu_ptr(percpu_count, cpu) = 0;
+        smp_store_release(&ref->percpu_count_ptr,
+                          ref->percpu_count_ptr & ~__PERCPU_REF_ATOMIC);
+}
+/**
+ * percpu_ref_switch_to_percpu - switch a percpu_ref to percpu mode
+ * @ref: percpu_ref to switch to percpu mode
+ *
+ * There's no reason to use this function for the usual reference counting.
+ * To re-use an expired ref, use percpu_ref_reinit().
+ *
+ * Switch @ref to percpu mode.  This function may be invoked concurrently
+ * with all the get/put operations and can safely be mixed with kill and
+ * reinit operations.  This function reverses the sticky atomic state set
+ * by PERCPU_REF_INIT_ATOMIC or percpu_ref_switch_to_atomic().  If @ref is
+ * dying or dead, the actual switching takes place on the following
+ * percpu_ref_reinit().
+ *
+ * This function normally doesn't block and can be called from any context
+ * but it may block if @ref is in the process of switching to atomic mode
+ * by percpu_ref_switch_atomic().
+ */
+void percpu_ref_switch_to_percpu(struct percpu_ref *ref)
+{
+        ref->force_atomic = false;
+        /* a dying or dead ref can't be switched to percpu mode w/o reinit */
+        if (!(ref->percpu_count_ptr & __PERCPU_REF_DEAD))
+                __percpu_ref_switch_to_percpu(ref);
 }
 /**
@@ -164,39 +284,48 @@ static void percpu_ref_kill_rcu(struct rcu_head *rcu)
 *
 * Equivalent to percpu_ref_kill() but also schedules kill confirmation if
 * @confirm_kill is not NULL.  @confirm_kill, which may not block, will be
- * called after @ref is seen as dead from all CPUs - all further
+ * called after @ref is seen as dead from all CPUs at which point all
- * invocations of percpu_ref_tryget() will fail.  See percpu_ref_tryget()
+ * further invocations of percpu_ref_tryget_live() will fail.  See
- * for more details.
+ * percpu_ref_tryget_live() for details.
+ *
+ * This function normally doesn't block and can be called from any context
+ * but it may block if @confirm_kill is specified and @ref is in the
+ * process of switching to atomic mode by percpu_ref_switch_atomic().
 *
- * Due to the way percpu_ref is implemented, @confirm_kill will be called
+ * Due to the way percpu_ref is implemented, @confirm_switch will be called
- * after at least one full RCU grace period has passed but this is an
+ * after at least one full sched RCU grace period has passed but this is an
- * implementation detail and callers must not depend on it.
+ * implementation detail and must not be depended upon.
 */
 void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
                                 percpu_ref_func_t *confirm_kill)
 {
-        WARN_ONCE(ref->pcpu_count_ptr & PCPU_REF_DEAD,
+        WARN_ONCE(ref->percpu_count_ptr & __PERCPU_REF_DEAD,
-                  "percpu_ref_kill() called more than once!\n");
+                  "%s called more than once on %pf!", __func__, ref->release);
-        ref->pcpu_count_ptr |= PCPU_REF_DEAD;
+        ref->percpu_count_ptr |= __PERCPU_REF_DEAD;
-        ref->confirm_kill = confirm_kill;
+        __percpu_ref_switch_to_atomic(ref, confirm_kill);
+        percpu_ref_put(ref);
-        call_rcu_sched(&ref->rcu, percpu_ref_kill_rcu);
 }
 EXPORT_SYMBOL_GPL(percpu_ref_kill_and_confirm);
-/*
+/**
- * XXX: Temporary kludge to work around SCSI blk-mq stall.  Used only by
+ * percpu_ref_reinit - re-initialize a percpu refcount
- * block/blk-mq.c::blk_mq_freeze_queue().  Will be removed during v3.18
+ * @ref: perpcu_ref to re-initialize
- * devel cycle.  Do not use anywhere else.
+ *
+ * Re-initialize @ref so that it's in the same state as when it finished
+ * percpu_ref_init() ignoring %PERCPU_REF_INIT_DEAD.  @ref must have been
+ * initialized successfully and reached 0 but not exited.
+ *
+ * Note that percpu_ref_tryget[_live]() are safe to perform on @ref while
+ * this function is in progress.
 */
-void __percpu_ref_kill_expedited(struct percpu_ref *ref)
+void percpu_ref_reinit(struct percpu_ref *ref)
 {
-        WARN_ONCE(ref->pcpu_count_ptr & PCPU_REF_DEAD,
+        WARN_ON_ONCE(!percpu_ref_is_zero(ref));
-                  "percpu_ref_kill() called more than once on %pf!",
-                  ref->release);
-        ref->pcpu_count_ptr |= PCPU_REF_DEAD;
+        ref->percpu_count_ptr &= ~__PERCPU_REF_DEAD;
-        synchronize_sched_expedited();
+        percpu_ref_get(ref);
-        percpu_ref_kill_rcu(&ref->rcu);
+        if (!ref->force_atomic)
+                __percpu_ref_switch_to_percpu(ref);
 }
+EXPORT_SYMBOL_GPL(percpu_ref_reinit);
diff --git a/lib/percpu_counter.c b/lib/percpu_counter.c
index 7dd33577b905..48144cdae819 100644
--- a/lib/percpu_counter.c
+++ b/lib/percpu_counter.c
@@ -112,13 +112,15 @@ s64 __percpu_counter_sum(struct percpu_counter *fbc)
 }
 EXPORT_SYMBOL(__percpu_counter_sum);
-int __percpu_counter_init(struct percpu_counter *fbc, s64 amount,
+int __percpu_counter_init(struct percpu_counter *fbc, s64 amount, gfp_t gfp,
                          struct lock_class_key *key)
 {
+        unsigned long flags __maybe_unused;
        raw_spin_lock_init(&fbc->lock);
        lockdep_set_class(&fbc->lock, key);
        fbc->count = amount;
-        fbc->counters = alloc_percpu(s32);
+        fbc->counters = alloc_percpu_gfp(s32, gfp);
        if (!fbc->counters)
                return -ENOMEM;
@@ -126,9 +128,9 @@ int __percpu_counter_init(struct percpu_counter *fbc, s64 amount,
 #ifdef CONFIG_HOTPLUG_CPU
        INIT_LIST_HEAD(&fbc->list);
-        spin_lock(&percpu_counters_lock);
+        spin_lock_irqsave(&percpu_counters_lock, flags);
        list_add(&fbc->list, &percpu_counters);
-        spin_unlock(&percpu_counters_lock);
+        spin_unlock_irqrestore(&percpu_counters_lock, flags);
 #endif
        return 0;
 }
@@ -136,15 +138,17 @@ EXPORT_SYMBOL(__percpu_counter_init);
 void percpu_counter_destroy(struct percpu_counter *fbc)
 {
+        unsigned long flags __maybe_unused;
        if (!fbc->counters)
                return;
        debug_percpu_counter_deactivate(fbc);
 #ifdef CONFIG_HOTPLUG_CPU
-        spin_lock(&percpu_counters_lock);
+        spin_lock_irqsave(&percpu_counters_lock, flags);
        list_del(&fbc->list);
-        spin_unlock(&percpu_counters_lock);
+        spin_unlock_irqrestore(&percpu_counters_lock, flags);
 #endif
        free_percpu(fbc->counters);
        fbc->counters = NULL;
@@ -173,7 +177,7 @@ static int percpu_counter_hotcpu_callback(struct notifier_block *nb,
                return NOTIFY_OK;
        cpu = (unsigned long)hcpu;
-        spin_lock(&percpu_counters_lock);
+        spin_lock_irq(&percpu_counters_lock);
        list_for_each_entry(fbc, &percpu_counters, list) {
                s32 *pcount;
                unsigned long flags;
@@ -184,7 +188,7 @@ static int percpu_counter_hotcpu_callback(struct notifier_block *nb,
                *pcount = 0;
                raw_spin_unlock_irqrestore(&fbc->lock, flags);
        }
-        spin_unlock(&percpu_counters_lock);
+        spin_unlock_irq(&percpu_counters_lock);
 #endif
        return NOTIFY_OK;
 }
diff --git a/lib/proportions.c b/lib/proportions.c
index 05df84801b56..6f724298f67a 100644
--- a/lib/proportions.c
+++ b/lib/proportions.c
@@ -73,7 +73,7 @@
 #include <linux/proportions.h>
 #include <linux/rcupdate.h>
-int prop_descriptor_init(struct prop_descriptor *pd, int shift)
+int prop_descriptor_init(struct prop_descriptor *pd, int shift, gfp_t gfp)
 {
        int err;
@@ -83,11 +83,11 @@ int prop_descriptor_init(struct prop_descriptor *pd, int shift)
        pd->index = 0;
        pd->pg[0].shift = shift;
        mutex_init(&pd->mutex);
-        err = percpu_counter_init(&pd->pg[0].events, 0);
+        err = percpu_counter_init(&pd->pg[0].events, 0, gfp);
        if (err)
                goto out;
-        err = percpu_counter_init(&pd->pg[1].events, 0);
+        err = percpu_counter_init(&pd->pg[1].events, 0, gfp);
        if (err)
                percpu_counter_destroy(&pd->pg[0].events);
@@ -188,12 +188,12 @@ prop_adjust_shift(int *pl_shift, unsigned long *pl_period, int new_shift)
 #define PROP_BATCH (8*(1+ilog2(nr_cpu_ids)))
-int prop_local_init_percpu(struct prop_local_percpu *pl)
+int prop_local_init_percpu(struct prop_local_percpu *pl, gfp_t gfp)
 {
        raw_spin_lock_init(&pl->lock);
        pl->shift = 0;
        pl->period = 0;
-        return percpu_counter_init(&pl->events, 0);
+        return percpu_counter_init(&pl->events, 0, gfp);
 }
 void prop_local_destroy_percpu(struct prop_local_percpu *pl)
author	Linus Torvalds <torvalds@linux-foundation.org>	2014-10-10 07:26:02 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2014-10-10 07:26:02 -0400
commit	c798360cd1438090d51eeaa8e67985da11362eba (patch)
tree	0107d3b9ee7476264c3357287787d393545bd2d9 /lib
parent	b211e9d7c861bdb37b86d6384da9edfb80949ceb (diff)
parent	6ae833c7fe0c6ef1f0ab13cc775da230d6f4c256 (diff)