10 files changed, 143 insertions, 102 deletions

diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index 280e71ee744c..5b4c6e649c11 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -195,7 +195,6 @@ void aoedev_exit(void);
 struct aoedev *aoedev_by_aoeaddr(int maj, int min);
 struct aoedev *aoedev_by_sysminor_m(ulong sysminor);
 void aoedev_downdev(struct aoedev *d);
-int aoedev_isbusy(struct aoedev *d);
 int aoedev_flush(const char __user *str, size_t size);
 
 int aoenet_init(void);
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index d00293ba3b45..8fc429cf82b6 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -668,16 +668,16 @@ ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
         u16 n;
 
         /* word 83: command set supported */
-        n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1]));
+        n = get_unaligned_le16(&id[83 << 1]);
 
         /* word 86: command set/feature enabled */
-        n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1]));
+        n |= get_unaligned_le16(&id[86 << 1]);
 
         if (n & (1<<10)) {      /* bit 10: LBA 48 */
                 d->flags |= DEVFL_EXT;
 
                 /* word 100: number lba48 sectors */
-                ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1]));
+                ssize = get_unaligned_le64(&id[100 << 1]);
 
                 /* set as in ide-disk.c:init_idedisk_capacity */
                 d->geo.cylinders = ssize;
@@ -688,12 +688,12 @@ ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
                 d->flags &= ~DEVFL_EXT;
 
                 /* number lba28 sectors */
-                ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1]));
+                ssize = get_unaligned_le32(&id[60 << 1]);
 
                 /* NOTE: obsolete in ATA 6 */
-                d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1]));
-                d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1]));
-                d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1]));
+                d->geo.cylinders = get_unaligned_le16(&id[54 << 1]);
+                d->geo.heads = get_unaligned_le16(&id[55 << 1]);
+                d->geo.sectors = get_unaligned_le16(&id[56 << 1]);
         }
 
         if (d->ssize != ssize)
@@ -779,7 +779,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
         u16 aoemajor;
 
         hin = (struct aoe_hdr *) skb_mac_header(skb);
-        aoemajor = be16_to_cpu(get_unaligned(&hin->major));
+        aoemajor = get_unaligned_be16(&hin->major);
         d = aoedev_by_aoeaddr(aoemajor, hin->minor);
         if (d == NULL) {
                 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
@@ -791,7 +791,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
 
         spin_lock_irqsave(&d->lock, flags);
 
-        n = be32_to_cpu(get_unaligned(&hin->tag));
+        n = get_unaligned_be32(&hin->tag);
         t = gettgt(d, hin->src);
         if (t == NULL) {
                 printk(KERN_INFO "aoe: can't find target e%ld.%d:%012llx\n",
@@ -806,9 +806,9 @@ aoecmd_ata_rsp(struct sk_buff *skb)
                 snprintf(ebuf, sizeof ebuf,
                         "%15s e%d.%d    tag=%08x@%08lx\n",
                         "unexpected rsp",
-                        be16_to_cpu(get_unaligned(&hin->major)),
+                        get_unaligned_be16(&hin->major),
                         hin->minor,
-                        be32_to_cpu(get_unaligned(&hin->tag)),
+                        get_unaligned_be32(&hin->tag),
                         jiffies);
                 aoechr_error(ebuf);
                 return;
@@ -873,7 +873,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
                         printk(KERN_INFO
                                 "aoe: unrecognized ata command %2.2Xh for %d.%d\n",
                                 ahout->cmdstat,
-                                be16_to_cpu(get_unaligned(&hin->major)),
+                                get_unaligned_be16(&hin->major),
                                 hin->minor);
                 }
         }
diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
index f9a1cd9edb77..a1d813ab0d6b 100644
--- a/drivers/block/aoe/aoedev.c
+++ b/drivers/block/aoe/aoedev.c
@@ -18,24 +18,6 @@ static void skbpoolfree(struct aoedev *d);
 static struct aoedev *devlist;
 static DEFINE_SPINLOCK(devlist_lock);
 
-int
-aoedev_isbusy(struct aoedev *d)
-{
-        struct aoetgt **t, **te;
-        struct frame *f, *e;
-
-        t = d->targets;
-        te = t + NTARGETS;
-        for (; t < te && *t; t++) {
-                f = (*t)->frames;
-                e = f + (*t)->nframes;
-                for (; f < e; f++)
-                        if (f->tag != FREETAG)
-                                return 1;
-        }
-        return 0;
-}
-
 struct aoedev *
 aoedev_by_aoeaddr(int maj, int min)
 {
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
index 18d243c73eee..d625169c8e48 100644
--- a/drivers/block/aoe/aoenet.c
+++ b/drivers/block/aoe/aoenet.c
@@ -128,7 +128,7 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
         skb_push(skb, ETH_HLEN);        /* (1) */
 
         h = (struct aoe_hdr *) skb_mac_header(skb);
-        n = be32_to_cpu(get_unaligned(&h->tag));
+        n = get_unaligned_be32(&h->tag);
         if ((h->verfl & AOEFL_RSP) == 0 || (n & 1<<31))
                 goto exit;
 
@@ -140,7 +140,7 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
                         printk(KERN_ERR
                                 "%s%d.%d@%s; ecode=%d '%s'\n",
                                 "aoe: error packet from ",
-                                be16_to_cpu(get_unaligned(&h->major)),
+                                get_unaligned_be16(&h->major),
                                 h->minor, skb->dev->name,
                                 h->err, aoe_errlist[n]);
                 goto exit;
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index cf6083a1f928..e539be5750dc 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -425,7 +425,7 @@ static void __devinit cciss_procinit(int i)
         struct proc_dir_entry *pde;
 
         if (proc_cciss == NULL)
-                proc_cciss = proc_mkdir("cciss", proc_root_driver);
+                proc_cciss = proc_mkdir("driver/cciss", NULL);
         if (!proc_cciss)
                 return;
         pde = proc_create(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
@@ -3700,7 +3700,7 @@ static void __exit cciss_cleanup(void)
                         cciss_remove_one(hba[i]->pdev);
                 }
         }
-        remove_proc_entry("cciss", proc_root_driver);
+        remove_proc_entry("driver/cciss", NULL);
 }
 
 static void fail_all_cmds(unsigned long ctlr)
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 69199185ff4b..09c14341e6e3 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -214,7 +214,7 @@ static struct proc_dir_entry *proc_array;
 static void __init ida_procinit(int i)
 {
         if (proc_array == NULL) {
-                proc_array = proc_mkdir("cpqarray", proc_root_driver);
+                proc_array = proc_mkdir("driver/cpqarray", NULL);
                 if (!proc_array) return;
         }
 
@@ -1796,7 +1796,7 @@ static void __exit cpqarray_exit(void)
                 }
         }
 
-        remove_proc_entry("cpqarray", proc_root_driver);
+        remove_proc_entry("driver/cpqarray", NULL);
 }
 
 module_init(cpqarray_init)
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 7652e87d60c5..395f8ea7981c 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4526,14 +4526,15 @@ static void __init parse_floppy_cfg_string(char *cfg)
         }
 }
 
-int __init init_module(void)
+static int __init floppy_module_init(void)
 {
         if (floppy)
                 parse_floppy_cfg_string(floppy);
         return floppy_init();
 }
+module_init(floppy_module_init);
 
-void cleanup_module(void)
+static void __exit floppy_module_exit(void)
 {
         int drive;
 
@@ -4562,6 +4563,7 @@ void cleanup_module(void)
         /* eject disk, if any */
         fd_eject(0);
 }
+module_exit(floppy_module_exit);
 
 module_param(floppy, charp, 0);
 module_param(FLOPPY_IRQ, int, 0);
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index f75bda16a1fc..ad98dda6037d 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -29,6 +29,7 @@
 #include <linux/kernel.h>
 #include <net/sock.h>
 #include <linux/net.h>
+#include <linux/kthread.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -55,6 +56,7 @@ static unsigned int debugflags;
 
 static unsigned int nbds_max = 16;
 static struct nbd_device *nbd_dev;
+static int max_part;
 
 /*
  * Use just one lock (or at most 1 per NIC). Two arguments for this:
@@ -337,7 +339,7 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
         }
 
         req = nbd_find_request(lo, *(struct request **)reply.handle);
-        if (unlikely(IS_ERR(req))) {
+        if (IS_ERR(req)) {
                 result = PTR_ERR(req);
                 if (result != -ENOENT)
                         goto harderror;
@@ -441,6 +443,85 @@ static void nbd_clear_que(struct nbd_device *lo)
 }
 
 
+static void nbd_handle_req(struct nbd_device *lo, struct request *req)
+{
+        if (!blk_fs_request(req))
+                goto error_out;
+
+        nbd_cmd(req) = NBD_CMD_READ;
+        if (rq_data_dir(req) == WRITE) {
+                nbd_cmd(req) = NBD_CMD_WRITE;
+                if (lo->flags & NBD_READ_ONLY) {
+                        printk(KERN_ERR "%s: Write on read-only\n",
+                                        lo->disk->disk_name);
+                        goto error_out;
+                }
+        }
+
+        req->errors = 0;
+
+        mutex_lock(&lo->tx_lock);
+        if (unlikely(!lo->sock)) {
+                mutex_unlock(&lo->tx_lock);
+                printk(KERN_ERR "%s: Attempted send on closed socket\n",
+                       lo->disk->disk_name);
+                req->errors++;
+                nbd_end_request(req);
+                return;
+        }
+
+        lo->active_req = req;
+
+        if (nbd_send_req(lo, req) != 0) {
+                printk(KERN_ERR "%s: Request send failed\n",
+                                lo->disk->disk_name);
+                req->errors++;
+                nbd_end_request(req);
+        } else {
+                spin_lock(&lo->queue_lock);
+                list_add(&req->queuelist, &lo->queue_head);
+                spin_unlock(&lo->queue_lock);
+        }
+
+        lo->active_req = NULL;
+        mutex_unlock(&lo->tx_lock);
+        wake_up_all(&lo->active_wq);
+
+        return;
+
+error_out:
+        req->errors++;
+        nbd_end_request(req);
+}
+
+static int nbd_thread(void *data)
+{
+        struct nbd_device *lo = data;
+        struct request *req;
+
+        set_user_nice(current, -20);
+        while (!kthread_should_stop() || !list_empty(&lo->waiting_queue)) {
+                /* wait for something to do */
+                wait_event_interruptible(lo->waiting_wq,
+                                         kthread_should_stop() ||
+                                         !list_empty(&lo->waiting_queue));
+
+                /* extract request */
+                if (list_empty(&lo->waiting_queue))
+                        continue;
+
+                spin_lock_irq(&lo->queue_lock);
+                req = list_entry(lo->waiting_queue.next, struct request,
+                                 queuelist);
+                list_del_init(&req->queuelist);
+                spin_unlock_irq(&lo->queue_lock);
+
+                /* handle request */
+                nbd_handle_req(lo, req);
+        }
+        return 0;
+}
+
 /*
  * We always wait for result of write, for now. It would be nice to make it optional
  * in future
@@ -456,65 +537,23 @@ static void do_nbd_request(struct request_queue * q)
                 struct nbd_device *lo;
 
                 blkdev_dequeue_request(req);
+
+                spin_unlock_irq(q->queue_lock);
+
                 dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
                                 req->rq_disk->disk_name, req, req->cmd_type);
 
-                if (!blk_fs_request(req))
-                        goto error_out;
-
                 lo = req->rq_disk->private_data;
 
                 BUG_ON(lo->magic != LO_MAGIC);
 
-                nbd_cmd(req) = NBD_CMD_READ;
-                if (rq_data_dir(req) == WRITE) {
-                        nbd_cmd(req) = NBD_CMD_WRITE;
-                        if (lo->flags & NBD_READ_ONLY) {
-                                printk(KERN_ERR "%s: Write on read-only\n",
-                                                lo->disk->disk_name);
-                                goto error_out;
-                        }
-                }
-
-                req->errors = 0;
-                spin_unlock_irq(q->queue_lock);
-
-                mutex_lock(&lo->tx_lock);
-                if (unlikely(!lo->sock)) {
-                        mutex_unlock(&lo->tx_lock);
-                        printk(KERN_ERR "%s: Attempted send on closed socket\n",
-                               lo->disk->disk_name);
-                        req->errors++;
-                        nbd_end_request(req);
-                        spin_lock_irq(q->queue_lock);
-                        continue;
-                }
-
-                lo->active_req = req;
+                spin_lock_irq(&lo->queue_lock);
+                list_add_tail(&req->queuelist, &lo->waiting_queue);
+                spin_unlock_irq(&lo->queue_lock);
 
-                if (nbd_send_req(lo, req) != 0) {
-                        printk(KERN_ERR "%s: Request send failed\n",
-                                        lo->disk->disk_name);
-                        req->errors++;
-                        nbd_end_request(req);
-                } else {
-                        spin_lock(&lo->queue_lock);
-                        list_add(&req->queuelist, &lo->queue_head);
-                        spin_unlock(&lo->queue_lock);
-                }
-
-                lo->active_req = NULL;
-                mutex_unlock(&lo->tx_lock);
-                wake_up_all(&lo->active_wq);
+                wake_up(&lo->waiting_wq);
 
                 spin_lock_irq(q->queue_lock);
-                continue;
-
-error_out:
-                req->errors++;
-                spin_unlock(q->queue_lock);
-                nbd_end_request(req);
-                spin_lock(q->queue_lock);
         }
 }
 
@@ -524,6 +563,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         struct nbd_device *lo = inode->i_bdev->bd_disk->private_data;
         int error;
         struct request sreq ;
+        struct task_struct *thread;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -572,10 +612,13 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                 error = -EINVAL;
                 file = fget(arg);
                 if (file) {
+                        struct block_device *bdev = inode->i_bdev;
                         inode = file->f_path.dentry->d_inode;
                         if (S_ISSOCK(inode->i_mode)) {
                                 lo->file = file;
                                 lo->sock = SOCKET_I(inode);
+                                if (max_part > 0)
+                                        bdev->bd_invalidated = 1;
                                 error = 0;
                         } else {
                                 fput(file);
@@ -607,7 +650,12 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         case NBD_DO_IT:
                 if (!lo->file)
                         return -EINVAL;
+                thread = kthread_create(nbd_thread, lo, lo->disk->disk_name);
+                if (IS_ERR(thread))
+                        return PTR_ERR(thread);
+                wake_up_process(thread);
                 error = nbd_do_it(lo);
+                kthread_stop(thread);
                 if (error)
                         return error;
                 sock_shutdown(lo, 1);
@@ -620,6 +668,8 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                 lo->bytesize = 0;
                 inode->i_bdev->bd_inode->i_size = 0;
                 set_capacity(lo->disk, 0);
+                if (max_part > 0)
+                        ioctl_by_bdev(inode->i_bdev, BLKRRPART, 0);
                 return lo->harderror;
         case NBD_CLEAR_QUE:
                 /*
@@ -653,6 +703,7 @@ static int __init nbd_init(void)
 {
         int err = -ENOMEM;
         int i;
+        int part_shift;
 
         BUILD_BUG_ON(sizeof(struct nbd_request) != 28);
 
@@ -660,8 +711,17 @@ static int __init nbd_init(void)
         if (!nbd_dev)
                 return -ENOMEM;
 
+        if (max_part < 0) {
+                printk(KERN_CRIT "nbd: max_part must be >= 0\n");
+                return -EINVAL;
+        }
+
+        part_shift = 0;
+        if (max_part > 0)
+                part_shift = fls(max_part);
+
         for (i = 0; i < nbds_max; i++) {
-                struct gendisk *disk = alloc_disk(1);
+                struct gendisk *disk = alloc_disk(1 << part_shift);
                 elevator_t *old_e;
                 if (!disk)
                         goto out;
@@ -696,17 +756,18 @@ static int __init nbd_init(void)
                 nbd_dev[i].file = NULL;
                 nbd_dev[i].magic = LO_MAGIC;
                 nbd_dev[i].flags = 0;
+                INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);
                 spin_lock_init(&nbd_dev[i].queue_lock);
                 INIT_LIST_HEAD(&nbd_dev[i].queue_head);
                 mutex_init(&nbd_dev[i].tx_lock);
                 init_waitqueue_head(&nbd_dev[i].active_wq);
+                init_waitqueue_head(&nbd_dev[i].waiting_wq);
                 nbd_dev[i].blksize = 1024;
                 nbd_dev[i].bytesize = 0;
                 disk->major = NBD_MAJOR;
-                disk->first_minor = i;
+                disk->first_minor = i << part_shift;
                 disk->fops = &nbd_fops;
                 disk->private_data = &nbd_dev[i];
-                disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
                 sprintf(disk->disk_name, "nbd%d", i);
                 set_capacity(disk, 0);
                 add_disk(disk);
@@ -744,7 +805,9 @@ MODULE_DESCRIPTION("Network Block Device");
 MODULE_LICENSE("GPL");
 
 module_param(nbds_max, int, 0444);
-MODULE_PARM_DESC(nbds_max, "How many network block devices to initialize.");
+MODULE_PARM_DESC(nbds_max, "number of network block devices to initialize (default: 16)");
+module_param(max_part, int, 0444);
+MODULE_PARM_DESC(max_part, "number of partitions per device (default: 0)");
 #ifndef NDEBUG
 module_param(debugflags, int, 0644);
 MODULE_PARM_DESC(debugflags, "flags for controlling debug output");
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 3b806c9fb005..3ba1df93e9e3 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2742,7 +2742,6 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         int i;
         int ret = 0;
         char b[BDEVNAME_SIZE];
-        struct proc_dir_entry *proc;
         struct block_device *bdev;
 
         if (pd->pkt_dev == dev) {
@@ -2786,11 +2785,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
                 goto out_mem;
         }
 
-        proc = create_proc_entry(pd->name, 0, pkt_proc);
-        if (proc) {
-                proc->data = pd;
-                proc->proc_fops = &pkt_proc_fops;
-        }
+        proc_create_data(pd->name, 0, pkt_proc, &pkt_proc_fops, pd);
         DPRINTK(DRIVER_NAME": writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
         return 0;
 
@@ -3099,7 +3094,7 @@ static int __init pkt_init(void)
                 goto out_misc;
         }
 
-        pkt_proc = proc_mkdir(DRIVER_NAME, proc_root_driver);
+        pkt_proc = proc_mkdir("driver/"DRIVER_NAME, NULL);
 
         return 0;
 
@@ -3115,7 +3110,7 @@ out2:
 
 static void __exit pkt_exit(void)
 {
-        remove_proc_entry(DRIVER_NAME, proc_root_driver);
+        remove_proc_entry("driver/"DRIVER_NAME, NULL);
         misc_deregister(&pkt_misc);
 
         pkt_debugfs_cleanup();
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index d771da816d95..f2fff5799ddf 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -137,7 +137,7 @@ static void blkif_restart_queue_callback(void *arg)
         schedule_work(&info->work);
 }
 
-int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
+static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
 {
         /* We don't have real geometry info, but let's at least return
            values consistent with the size of the device */