Merge branch 'for-3.13/core' of git://git.kernel.dk/linux-block

Pull block IO core updates from Jens Axboe:
 "This is the pull request for the core changes in the block layer for
  3.13.  It contains:

   - The new blk-mq request interface.

     This is a new and more scalable queueing model that marries the
     best part of the request based interface we currently have (which
     is fully featured, but scales poorly) and the bio based "interface"
     which the new drivers for high IOPS devices end up using because
     it's much faster than the request based one.

     The bio interface has no block layer support, since it taps into
     the stack much earlier.  This means that drivers end up having to
     implement a lot of functionality on their own, like tagging,
     timeout handling, requeue, etc.  The blk-mq interface provides all
     these.  Some drivers even provide a switch to select bio or rq and
     has code to handle both, since things like merging only works in
     the rq model and hence is faster for some workloads.  This is a
     huge mess.  Conversion of these drivers nets us a substantial code
     reduction.  Initial results on converting SCSI to this model even
     shows an 8x improvement on single queue devices.  So while the
     model was intended to work on the newer multiqueue devices, it has
     substantial improvements for "classic" hardware as well.  This code
     has gone through extensive testing and development, it's now ready
     to go.  A pull request is coming to convert virtio-blk to this
     model will be will be coming as well, with more drivers scheduled
     for 3.14 conversion.

   - Two blktrace fixes from Jan and Chen Gang.

   - A plug merge fix from Alireza Haghdoost.

   - Conversion of __get_cpu_var() from Christoph Lameter.

   - Fix for sector_div() with 64-bit divider from Geert Uytterhoeven.

   - A fix for a race between request completion and the timeout
     handling from Jeff Moyer.  This is what caused the merge conflict
     with blk-mq/core, in case you are looking at that.

   - A dm stacking fix from Mike Snitzer.

   - A code consolidation fix and duplicated code removal from Kent
     Overstreet.

   - A handful of block bug fixes from Mikulas Patocka, fixing a loop
     crash and memory corruption on blk cg.

   - Elevator switch bug fix from Tomoki Sekiyama.

  A heads-up that I had to rebase this branch.  Initially the immutable
  bio_vecs had been queued up for inclusion, but a week later, it became
  clear that it wasn't fully cooked yet.  So the decision was made to
  pull this out and postpone it until 3.14.  It was a straight forward
  rebase, just pruning out the immutable series and the later fixes of
  problems with it.  The rest of the patches applied directly and no
  further changes were made"

* 'for-3.13/core' of git://git.kernel.dk/linux-block: (31 commits)
  block: replace IS_ERR and PTR_ERR with PTR_ERR_OR_ZERO
  block: replace IS_ERR and PTR_ERR with PTR_ERR_OR_ZERO
  block: Do not call sector_div() with a 64-bit divisor
  kernel: trace: blktrace: remove redundent memcpy() in compat_blk_trace_setup()
  block: Consolidate duplicated bio_trim() implementations
  block: Use rw_copy_check_uvector()
  block: Enable sysfs nomerge control for I/O requests in the plug list
  block: properly stack underlying max_segment_size to DM device
  elevator: acquire q->sysfs_lock in elevator_change()
  elevator: Fix a race in elevator switching and md device initialization
  block: Replace __get_cpu_var uses
  bdi: test bdi_init failure
  block: fix a probe argument to blk_register_region
  loop: fix crash if blk_alloc_queue fails
  blk-core: Fix memory corruption if blkcg_init_queue fails
  block: fix race between request completion and timeout handling
  blktrace: Send BLK_TN_PROCESS events to all running traces
  blk-mq: don't disallow request merges for req->special being set
  blk-mq: mq plug list breakage
  blk-mq: fix for flush deadlock
  ...

2 files changed, 81 insertions, 23 deletions

diff --git a/lib/percpu_counter.c b/lib/percpu_counter.c
index 93c5d5ecff4e..7473ee3b4ee7 100644
--- a/lib/percpu_counter.c
+++ b/lib/percpu_counter.c
@@ -60,14 +60,15 @@ static inline void debug_percpu_counter_deactivate(struct percpu_counter *fbc)
 void percpu_counter_set(struct percpu_counter *fbc, s64 amount)
 {
         int cpu;
+        unsigned long flags;
 
-        raw_spin_lock(&fbc->lock);
+        raw_spin_lock_irqsave(&fbc->lock, flags);
         for_each_possible_cpu(cpu) {
                 s32 *pcount = per_cpu_ptr(fbc->counters, cpu);
                 *pcount = 0;
         }
         fbc->count = amount;
-        raw_spin_unlock(&fbc->lock);
+        raw_spin_unlock_irqrestore(&fbc->lock, flags);
 }
 EXPORT_SYMBOL(percpu_counter_set);
 
@@ -78,9 +79,10 @@ void __percpu_counter_add(struct percpu_counter *fbc, s64 amount, s32 batch)
         preempt_disable();
         count = __this_cpu_read(*fbc->counters) + amount;
         if (count >= batch || count <= -batch) {
-                raw_spin_lock(&fbc->lock);
+                unsigned long flags;
+                raw_spin_lock_irqsave(&fbc->lock, flags);
                 fbc->count += count;
-                raw_spin_unlock(&fbc->lock);
+                raw_spin_unlock_irqrestore(&fbc->lock, flags);
                 __this_cpu_write(*fbc->counters, 0);
         } else {
                 __this_cpu_write(*fbc->counters, count);
@@ -97,14 +99,15 @@ s64 __percpu_counter_sum(struct percpu_counter *fbc)
 {
         s64 ret;
         int cpu;
+        unsigned long flags;
 
-        raw_spin_lock(&fbc->lock);
+        raw_spin_lock_irqsave(&fbc->lock, flags);
         ret = fbc->count;
         for_each_online_cpu(cpu) {
                 s32 *pcount = per_cpu_ptr(fbc->counters, cpu);
                 ret += *pcount;
         }
-        raw_spin_unlock(&fbc->lock);
+        raw_spin_unlock_irqrestore(&fbc->lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(__percpu_counter_sum);
diff --git a/lib/percpu_ida.c b/lib/percpu_ida.c
index bab1ba2a4c71..b0698ea972c6 100644
--- a/lib/percpu_ida.c
+++ b/lib/percpu_ida.c
@@ -30,15 +30,6 @@
 #include <linux/spinlock.h>
 #include <linux/percpu_ida.h>
 
-/*
- * Number of tags we move between the percpu freelist and the global freelist at
- * a time
- */
-#define IDA_PCPU_BATCH_MOVE     32U
-
-/* Max size of percpu freelist, */
-#define IDA_PCPU_SIZE           ((IDA_PCPU_BATCH_MOVE * 3) / 2)
-
 struct percpu_ida_cpu {
         /*
          * Even though this is percpu, we need a lock for tag stealing by remote
@@ -78,7 +69,7 @@ static inline void steal_tags(struct percpu_ida *pool,
         struct percpu_ida_cpu *remote;
 
         for (cpus_have_tags = cpumask_weight(&pool->cpus_have_tags);
-             cpus_have_tags * IDA_PCPU_SIZE > pool->nr_tags / 2;
+             cpus_have_tags * pool->percpu_max_size > pool->nr_tags / 2;
              cpus_have_tags--) {
                 cpu = cpumask_next(cpu, &pool->cpus_have_tags);
 
@@ -123,7 +114,7 @@ static inline void alloc_global_tags(struct percpu_ida *pool,
 {
         move_tags(tags->freelist, &tags->nr_free,
                   pool->freelist, &pool->nr_free,
-                  min(pool->nr_free, IDA_PCPU_BATCH_MOVE));
+                  min(pool->nr_free, pool->percpu_batch_size));
 }
 
 static inline unsigned alloc_local_tag(struct percpu_ida *pool,
@@ -245,17 +236,17 @@ void percpu_ida_free(struct percpu_ida *pool, unsigned tag)
                 wake_up(&pool->wait);
         }
 
-        if (nr_free == IDA_PCPU_SIZE) {
+        if (nr_free == pool->percpu_max_size) {
                 spin_lock(&pool->lock);
 
                 /*
                  * Global lock held and irqs disabled, don't need percpu
                  * lock
                  */
-                if (tags->nr_free == IDA_PCPU_SIZE) {
+                if (tags->nr_free == pool->percpu_max_size) {
                         move_tags(pool->freelist, &pool->nr_free,
                                   tags->freelist, &tags->nr_free,
-                                  IDA_PCPU_BATCH_MOVE);
+                                  pool->percpu_batch_size);
 
                         wake_up(&pool->wait);
                 }
@@ -292,7 +283,8 @@ EXPORT_SYMBOL_GPL(percpu_ida_destroy);
  * Allocation is percpu, but sharding is limited by nr_tags - for best
  * performance, the workload should not span more cpus than nr_tags / 128.
  */
-int percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags)
+int __percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags,
+        unsigned long max_size, unsigned long batch_size)
 {
         unsigned i, cpu, order;
 
@@ -301,6 +293,8 @@ int percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags)
         init_waitqueue_head(&pool->wait);
         spin_lock_init(&pool->lock);
         pool->nr_tags = nr_tags;
+        pool->percpu_max_size = max_size;
+        pool->percpu_batch_size = batch_size;
 
         /* Guard against overflow */
         if (nr_tags > (unsigned) INT_MAX + 1) {
@@ -319,7 +313,7 @@ int percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags)
         pool->nr_free = nr_tags;
 
         pool->tag_cpu = __alloc_percpu(sizeof(struct percpu_ida_cpu) +
-                                       IDA_PCPU_SIZE * sizeof(unsigned),
+                                       pool->percpu_max_size * sizeof(unsigned),
                                        sizeof(unsigned));
         if (!pool->tag_cpu)
                 goto err;
@@ -332,4 +326,65 @@ err:
         percpu_ida_destroy(pool);
         return -ENOMEM;
 }
-EXPORT_SYMBOL_GPL(percpu_ida_init);
+EXPORT_SYMBOL_GPL(__percpu_ida_init);
+
+/**
+ * percpu_ida_for_each_free - iterate free ids of a pool
+ * @pool: pool to iterate
+ * @fn: interate callback function
+ * @data: parameter for @fn
+ *
+ * Note, this doesn't guarantee to iterate all free ids restrictly. Some free
+ * ids might be missed, some might be iterated duplicated, and some might
+ * be iterated and not free soon.
+ */
+int percpu_ida_for_each_free(struct percpu_ida *pool, percpu_ida_cb fn,
+        void *data)
+{
+        unsigned long flags;
+        struct percpu_ida_cpu *remote;
+        unsigned cpu, i, err = 0;
+
+        local_irq_save(flags);
+        for_each_possible_cpu(cpu) {
+                remote = per_cpu_ptr(pool->tag_cpu, cpu);
+                spin_lock(&remote->lock);
+                for (i = 0; i < remote->nr_free; i++) {
+                        err = fn(remote->freelist[i], data);
+                        if (err)
+                                break;
+                }
+                spin_unlock(&remote->lock);
+                if (err)
+                        goto out;
+        }
+
+        spin_lock(&pool->lock);
+        for (i = 0; i < pool->nr_free; i++) {
+                err = fn(pool->freelist[i], data);
+                if (err)
+                        break;
+        }
+        spin_unlock(&pool->lock);
+out:
+        local_irq_restore(flags);
+        return err;
+}
+EXPORT_SYMBOL_GPL(percpu_ida_for_each_free);
+
+/**
+ * percpu_ida_free_tags - return free tags number of a specific cpu or global pool
+ * @pool: pool related
+ * @cpu: specific cpu or global pool if @cpu == nr_cpu_ids
+ *
+ * Note: this just returns a snapshot of free tags number.
+ */
+unsigned percpu_ida_free_tags(struct percpu_ida *pool, int cpu)
+{
+        struct percpu_ida_cpu *remote;
+        if (cpu == nr_cpu_ids)
+                return pool->nr_free;
+        remote = per_cpu_ptr(pool->tag_cpu, cpu);
+        return remote->nr_free;
+}
+EXPORT_SYMBOL_GPL(percpu_ida_free_tags);