Merge branch 'akpm' (updates from Andrew Morton)

Merge first patch-bomb from Andrew Morton:
 - various misc bits
 - I'm been patchmonkeying ocfs2 for a while, as Joel and Mark have been
   distracted.  There has been quite a bit of activity.
 - About half the MM queue
 - Some backlight bits
 - Various lib/ updates
 - checkpatch updates
 - zillions more little rtc patches
 - ptrace
 - signals
 - exec
 - procfs
 - rapidio
 - nbd
 - aoe
 - pps
 - memstick
 - tools/testing/selftests updates

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (445 commits)
  tools/testing/selftests: don't assume the x bit is set on scripts
  selftests: add .gitignore for kcmp
  selftests: fix clean target in kcmp Makefile
  selftests: add .gitignore for vm
  selftests: add hugetlbfstest
  self-test: fix make clean
  selftests: exit 1 on failure
  kernel/resource.c: remove the unneeded assignment in function __find_resource
  aio: fix wrong comment in aio_complete()
  drivers/w1/slaves/w1_ds2408.c: add magic sequence to disable P0 test mode
  drivers/memstick/host/r592.c: convert to module_pci_driver
  drivers/memstick/host/jmb38x_ms: convert to module_pci_driver
  pps-gpio: add device-tree binding and support
  drivers/pps/clients/pps-gpio.c: convert to module_platform_driver
  drivers/pps/clients/pps-gpio.c: convert to devm_* helpers
  drivers/parport/share.c: use kzalloc
  Documentation/accounting/getdelays.c: avoid strncpy in accounting tool
  aoe: update internal version number to v83
  aoe: update copyright date
  aoe: perform I/O completions in parallel
  ...

7 files changed, 151 insertions, 42 deletions

diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index 175649468c95..025c41d3cb33 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -1,5 +1,5 @@
-/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
-#define VERSION "81"
+/* Copyright (c) 2013 Coraid, Inc.  See COPYING for GPL terms. */
+#define VERSION "83"
 #define AOE_MAJOR 152
 #define DEVICE_NAME "aoe"
 
@@ -196,9 +196,11 @@ struct ktstate {
         struct completion rendez;
         struct task_struct *task;
         wait_queue_head_t *waitq;
-        int (*fn) (void);
-        char *name;
+        int (*fn) (int);
+        char name[12];
         spinlock_t *lock;
+        int id;
+        int active;
 };
 
 int aoeblk_init(void);
@@ -222,6 +224,7 @@ int aoecmd_init(void);
 struct sk_buff *aoecmd_ata_id(struct aoedev *);
 void aoe_freetframe(struct frame *);
 void aoe_flush_iocq(void);
+void aoe_flush_iocq_by_index(int);
 void aoe_end_request(struct aoedev *, struct request *, int);
 int aoe_ktstart(struct ktstate *k);
 void aoe_ktstop(struct ktstate *k);
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index fc803ecbbce4..99cb944a002d 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2013 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoecmd.c
  * Filesystem request handling methods
@@ -35,14 +35,27 @@ module_param(aoe_maxout, int, 0644);
 MODULE_PARM_DESC(aoe_maxout,
         "Only aoe_maxout outstanding packets for every MAC on eX.Y.");
 
-static wait_queue_head_t ktiowq;
-static struct ktstate kts;
+/* The number of online cpus during module initialization gives us a
+ * convenient heuristic cap on the parallelism used for ktio threads
+ * doing I/O completion.  It is not important that the cap equal the
+ * actual number of running CPUs at any given time, but because of CPU
+ * hotplug, we take care to use ncpus instead of using
+ * num_online_cpus() after module initialization.
+ */
+static int ncpus;
+
+/* mutex lock used for synchronization while thread spawning */
+static DEFINE_MUTEX(ktio_spawn_lock);
+
+static wait_queue_head_t *ktiowq;
+static struct ktstate *kts;
 
 /* io completion queue */
-static struct {
+struct iocq_ktio {
         struct list_head head;
         spinlock_t lock;
-} iocq;
+};
+static struct iocq_ktio *iocq;
 
 static struct page *empty_page;
 
@@ -1278,23 +1291,36 @@ out:
  * Returns true iff responses needing processing remain.
  */
 static int
-ktio(void)
+ktio(int id)
 {
         struct frame *f;
         struct list_head *pos;
         int i;
+        int actual_id;
 
         for (i = 0; ; ++i) {
                 if (i == MAXIOC)
                         return 1;
-                if (list_empty(&iocq.head))
+                if (list_empty(&iocq[id].head))
                         return 0;
-                pos = iocq.head.next;
+                pos = iocq[id].head.next;
                 list_del(pos);
-                spin_unlock_irq(&iocq.lock);
                 f = list_entry(pos, struct frame, head);
+                spin_unlock_irq(&iocq[id].lock);
                 ktiocomplete(f);
-                spin_lock_irq(&iocq.lock);
+
+                /* Figure out if extra threads are required. */
+                actual_id = f->t->d->aoeminor % ncpus;
+
+                if (!kts[actual_id].active) {
+                        BUG_ON(id != 0);
+                        mutex_lock(&ktio_spawn_lock);
+                        if (!kts[actual_id].active
+                                && aoe_ktstart(&kts[actual_id]) == 0)
+                                kts[actual_id].active = 1;
+                        mutex_unlock(&ktio_spawn_lock);
+                }
+                spin_lock_irq(&iocq[id].lock);
         }
 }
 
@@ -1311,7 +1337,7 @@ kthread(void *vp)
         complete(&k->rendez);   /* tell spawner we're running */
         do {
                 spin_lock_irq(k->lock);
-                more = k->fn();
+                more = k->fn(k->id);
                 if (!more) {
                         add_wait_queue(k->waitq, &wait);
                         __set_current_state(TASK_INTERRUPTIBLE);
@@ -1340,7 +1366,7 @@ aoe_ktstart(struct ktstate *k)
         struct task_struct *task;
 
         init_completion(&k->rendez);
-        task = kthread_run(kthread, k, k->name);
+        task = kthread_run(kthread, k, "%s", k->name);
         if (task == NULL || IS_ERR(task))
                 return -ENOMEM;
         k->task = task;
@@ -1353,13 +1379,24 @@ aoe_ktstart(struct ktstate *k)
 static void
 ktcomplete(struct frame *f, struct sk_buff *skb)
 {
+        int id;
         ulong flags;
 
         f->r_skb = skb;
-        spin_lock_irqsave(&iocq.lock, flags);
-        list_add_tail(&f->head, &iocq.head);
-        spin_unlock_irqrestore(&iocq.lock, flags);
-        wake_up(&ktiowq);
+        id = f->t->d->aoeminor % ncpus;
+        spin_lock_irqsave(&iocq[id].lock, flags);
+        if (!kts[id].active) {
+                spin_unlock_irqrestore(&iocq[id].lock, flags);
+                /* The thread with id has not been spawned yet,
+                 * so delegate the work to the main thread and
+                 * try spawning a new thread.
+                 */
+                id = 0;
+                spin_lock_irqsave(&iocq[id].lock, flags);
+        }
+        list_add_tail(&f->head, &iocq[id].head);
+        spin_unlock_irqrestore(&iocq[id].lock, flags);
+        wake_up(&ktiowq[id]);
 }
 
 struct sk_buff *
@@ -1706,6 +1743,17 @@ aoe_failbuf(struct aoedev *d, struct buf *buf)
 void
 aoe_flush_iocq(void)
 {
+        int i;
+
+        for (i = 0; i < ncpus; i++) {
+                if (kts[i].active)
+                        aoe_flush_iocq_by_index(i);
+        }
+}
+
+void
+aoe_flush_iocq_by_index(int id)
+{
         struct frame *f;
         struct aoedev *d;
         LIST_HEAD(flist);
@@ -1713,9 +1761,9 @@ aoe_flush_iocq(void)
         struct sk_buff *skb;
         ulong flags;
 
-        spin_lock_irqsave(&iocq.lock, flags);
-        list_splice_init(&iocq.head, &flist);
-        spin_unlock_irqrestore(&iocq.lock, flags);
+        spin_lock_irqsave(&iocq[id].lock, flags);
+        list_splice_init(&iocq[id].head, &flist);
+        spin_unlock_irqrestore(&iocq[id].lock, flags);
         while (!list_empty(&flist)) {
                 pos = flist.next;
                 list_del(pos);
@@ -1738,6 +1786,8 @@ int __init
 aoecmd_init(void)
 {
         void *p;
+        int i;
+        int ret;
 
         /* get_zeroed_page returns page with ref count 1 */
         p = (void *) get_zeroed_page(GFP_KERNEL | __GFP_REPEAT);
@@ -1745,22 +1795,72 @@ aoecmd_init(void)
                 return -ENOMEM;
         empty_page = virt_to_page(p);
 
-        INIT_LIST_HEAD(&iocq.head);
-        spin_lock_init(&iocq.lock);
-        init_waitqueue_head(&ktiowq);
-        kts.name = "aoe_ktio";
-        kts.fn = ktio;
-        kts.waitq = &ktiowq;
-        kts.lock = &iocq.lock;
-        return aoe_ktstart(&kts);
+        ncpus = num_online_cpus();
+
+        iocq = kcalloc(ncpus, sizeof(struct iocq_ktio), GFP_KERNEL);
+        if (!iocq)
+                return -ENOMEM;
+
+        kts = kcalloc(ncpus, sizeof(struct ktstate), GFP_KERNEL);
+        if (!kts) {
+                ret = -ENOMEM;
+                goto kts_fail;
+        }
+
+        ktiowq = kcalloc(ncpus, sizeof(wait_queue_head_t), GFP_KERNEL);
+        if (!ktiowq) {
+                ret = -ENOMEM;
+                goto ktiowq_fail;
+        }
+
+        mutex_init(&ktio_spawn_lock);
+
+        for (i = 0; i < ncpus; i++) {
+                INIT_LIST_HEAD(&iocq[i].head);
+                spin_lock_init(&iocq[i].lock);
+                init_waitqueue_head(&ktiowq[i]);
+                snprintf(kts[i].name, sizeof(kts[i].name), "aoe_ktio%d", i);
+                kts[i].fn = ktio;
+                kts[i].waitq = &ktiowq[i];
+                kts[i].lock = &iocq[i].lock;
+                kts[i].id = i;
+                kts[i].active = 0;
+        }
+        kts[0].active = 1;
+        if (aoe_ktstart(&kts[0])) {
+                ret = -ENOMEM;
+                goto ktstart_fail;
+        }
+        return 0;
+
+ktstart_fail:
+        kfree(ktiowq);
+ktiowq_fail:
+        kfree(kts);
+kts_fail:
+        kfree(iocq);
+
+        return ret;
 }
 
 void
 aoecmd_exit(void)
 {
-        aoe_ktstop(&kts);
+        int i;
+
+        for (i = 0; i < ncpus; i++)
+                if (kts[i].active)
+                        aoe_ktstop(&kts[i]);
+
         aoe_flush_iocq();
 
+        /* Free up the iocq and thread speicific configuration
+        * allocated during startup.
+        */
+        kfree(iocq);
+        kfree(kts);
+        kfree(ktiowq);
+
         free_page((unsigned long) page_address(empty_page));
         empty_page = NULL;
 }
diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
index 98f2965778b9..784c92e038d1 100644
--- a/drivers/block/aoe/aoedev.c
+++ b/drivers/block/aoe/aoedev.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2013 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoedev.c
  * AoE device utility functions; maintains device list.
@@ -518,7 +518,6 @@ void
 aoedev_exit(void)
 {
         flush_scheduled_work();
-        aoe_flush_iocq();
         flush(NULL, 0, EXITING);
 }
 
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
index 71d3ea8d3006..63773a90581d 100644
--- a/drivers/block/aoe/aoenet.c
+++ b/drivers/block/aoe/aoenet.c
@@ -1,4 +1,4 @@
-/* Copyright (c) 2012 Coraid, Inc.  See COPYING for GPL terms. */
+/* Copyright (c) 2013 Coraid, Inc.  See COPYING for GPL terms. */
 /*
  * aoenet.c
  * Ethernet portion of AoE driver
@@ -52,7 +52,7 @@ static struct sk_buff_head skbtxq;
 
 /* enters with txlock held */
 static int
-tx(void) __must_hold(&txlock)
+tx(int id) __must_hold(&txlock)
 {
         struct sk_buff *skb;
         struct net_device *ifp;
@@ -205,7 +205,8 @@ aoenet_init(void)
         kts.lock = &txlock;
         kts.fn = tx;
         kts.waitq = &txwq;
-        kts.name = "aoe_tx";
+        kts.id = 0;
+        snprintf(kts.name, sizeof(kts.name), "aoe_tx%d", kts.id);
         if (aoe_ktstart(&kts))
                 return -EAGAIN;
         dev_add_pack(&aoe_pt);
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 20dd52a2f92f..952dbfe22126 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -4087,7 +4087,8 @@ skip_create_disk:
 start_service_thread:
         sprintf(thd_name, "mtip_svc_thd_%02d", index);
         dd->mtip_svc_handler = kthread_create_on_node(mtip_service_thread,
-                                                dd, dd->numa_node, thd_name);
+                                                dd, dd->numa_node, "%s",
+                                                thd_name);
 
         if (IS_ERR(dd->mtip_svc_handler)) {
                 dev_err(&dd->pdev->dev, "service thread failed to start\n");
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 037288e7874d..2dc3b5153f0d 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -623,8 +623,10 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 if (!nbd->sock)
                         return -EINVAL;
 
+                nbd->disconnect = 1;
+
                 nbd_send_req(nbd, &sreq);
-                return 0;
+                return 0;
         }
  
         case NBD_CLEAR_SOCK: {
@@ -654,6 +656,7 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                                 nbd->sock = SOCKET_I(inode);
                                 if (max_part > 0)
                                         bdev->bd_invalidated = 1;
+                                nbd->disconnect = 0; /* we're connected now */
                                 return 0;
                         } else {
                                 fput(file);
@@ -714,7 +717,8 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 else
                         blk_queue_flush(nbd->disk->queue, 0);
 
-                thread = kthread_create(nbd_thread, nbd, nbd->disk->disk_name);
+                thread = kthread_create(nbd_thread, nbd, "%s",
+                                        nbd->disk->disk_name);
                 if (IS_ERR(thread)) {
                         mutex_lock(&nbd->tx_lock);
                         return PTR_ERR(thread);
@@ -742,6 +746,8 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                 set_capacity(nbd->disk, 0);
                 if (max_part > 0)
                         ioctl_by_bdev(bdev, BLKRRPART, 0);
+                if (nbd->disconnect) /* user requested, ignore socket errors */
+                        return 0;
                 return nbd->harderror;
         }
 
@@ -750,7 +756,6 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *nbd,
                  * This is for compatibility only.  The queue is always cleared
                  * by NBD_DO_IT or NBD_CLEAR_SOCK.
                  */
-                BUG_ON(!nbd->sock && !list_empty(&nbd->queue_head));
                 return 0;
 
         case NBD_PRINT_DEBUG:
diff --git a/drivers/block/xen-blkback/xenbus.c b/drivers/block/xen-blkback/xenbus.c
index 8bfd1bcf95ec..04608a6502d7 100644
--- a/drivers/block/xen-blkback/xenbus.c
+++ b/drivers/block/xen-blkback/xenbus.c
@@ -93,7 +93,7 @@ static void xen_update_blkif_status(struct xen_blkif *blkif)
         }
         invalidate_inode_pages2(blkif->vbd.bdev->bd_inode->i_mapping);
 
-        blkif->xenblkd = kthread_run(xen_blkif_schedule, blkif, name);
+        blkif->xenblkd = kthread_run(xen_blkif_schedule, blkif, "%s", name);
         if (IS_ERR(blkif->xenblkd)) {
                 err = PTR_ERR(blkif->xenblkd);
                 blkif->xenblkd = NULL;