9 files changed, 314 insertions, 221 deletions

diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 17ee97f3a99b..b4c8319138b2 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -444,8 +444,6 @@ config CDROM_PKTCDVD_WCACHE
           this option is dangerous unless the CD-RW media is known good, as we
           don't do deferred write error handling yet.
 
-source "drivers/s390/block/Kconfig"
-
 config ATA_OVER_ETH
         tristate "ATA over Ethernet support"
         depends on NET
@@ -453,6 +451,8 @@ config ATA_OVER_ETH
         This driver provides Support for ATA over Ethernet block
         devices like the Coraid EtherDrive (R) Storage Blade.
 
+source "drivers/s390/block/Kconfig"
+
 endmenu
 
 endif
diff --git a/drivers/block/acsi_slm.c b/drivers/block/acsi_slm.c
index e2e043290963..1d9d9b4f48cc 100644
--- a/drivers/block/acsi_slm.c
+++ b/drivers/block/acsi_slm.c
@@ -65,7 +65,6 @@ not be guaranteed. There are several ways to assure this:
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 
 #include <asm/pgtable.h>
 #include <asm/system.h>
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 65a725cd3422..5acc6c44aead 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -45,6 +45,10 @@
 #include <linux/blkdev.h>
 #include <linux/genhd.h>
 #include <linux/completion.h>
+#include <scsi/scsi.h>
+#include <scsi/sg.h>
+#include <scsi/scsi_ioctl.h>
+#include <linux/cdrom.h>
 
 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
 #define DRIVER_NAME "HP CISS Driver (v 3.6.14)"
@@ -1152,6 +1156,30 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                         kfree(ioc);
                         return status;
                 }
+
+        /* scsi_cmd_ioctl handles these, below, though some are not */
+        /* very meaningful for cciss.  SG_IO is the main one people want. */
+
+        case SG_GET_VERSION_NUM:
+        case SG_SET_TIMEOUT:
+        case SG_GET_TIMEOUT:
+        case SG_GET_RESERVED_SIZE:
+        case SG_SET_RESERVED_SIZE:
+        case SG_EMULATED_HOST:
+        case SG_IO:
+        case SCSI_IOCTL_SEND_COMMAND:
+                return scsi_cmd_ioctl(filep, disk, cmd, argp);
+
+        /* scsi_cmd_ioctl would normally handle these, below, but */
+        /* they aren't a good fit for cciss, as CD-ROMs are */
+        /* not supported, and we don't have any bus/target/lun */
+        /* which we present to the kernel. */
+
+        case CDROM_SEND_PACKET:
+        case CDROMCLOSETRAY:
+        case CDROMEJECT:
+        case SCSI_IOCTL_GET_IDLUN:
+        case SCSI_IOCTL_GET_BUS_NUMBER:
         default:
                 return -ENOTTY;
         }
@@ -1234,7 +1262,7 @@ static void cciss_softirq_done(struct request *rq)
                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
         }
 
-        complete_buffers(rq->bio, rq->errors);
+        complete_buffers(rq->bio, (rq->errors == 0));
 
         if (blk_fs_request(rq)) {
                 const int rw = rq_data_dir(rq);
@@ -1248,7 +1276,7 @@ static void cciss_softirq_done(struct request *rq)
 
         add_disk_randomness(rq->rq_disk);
         spin_lock_irqsave(&h->lock, flags);
-        end_that_request_last(rq, rq->errors);
+        end_that_request_last(rq, (rq->errors == 0));
         cmd_free(h, cmd, 1);
         cciss_check_queues(h);
         spin_unlock_irqrestore(&h->lock, flags);
@@ -2336,6 +2364,44 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
         start_io(h);
 }
 
+static inline int evaluate_target_status(CommandList_struct *cmd)
+{
+        unsigned char sense_key;
+        int error_count = 1;
+
+        if (cmd->err_info->ScsiStatus != 0x02) { /* not check condition? */
+                if (!blk_pc_request(cmd->rq))
+                        printk(KERN_WARNING "cciss: cmd %p "
+                               "has SCSI Status 0x%x\n",
+                               cmd, cmd->err_info->ScsiStatus);
+                return error_count;
+        }
+
+        /* check the sense key */
+        sense_key = 0xf & cmd->err_info->SenseInfo[2];
+        /* no status or recovered error */
+        if ((sense_key == 0x0) || (sense_key == 0x1))
+                error_count = 0;
+
+        if (!blk_pc_request(cmd->rq)) { /* Not SG_IO or similar? */
+                if (error_count != 0)
+                        printk(KERN_WARNING "cciss: cmd %p has CHECK CONDITION"
+                               " sense key = 0x%x\n", cmd, sense_key);
+                return error_count;
+        }
+
+        /* SG_IO or similar, copy sense data back */
+        if (cmd->rq->sense) {
+                if (cmd->rq->sense_len > cmd->err_info->SenseLen)
+                        cmd->rq->sense_len = cmd->err_info->SenseLen;
+                memcpy(cmd->rq->sense, cmd->err_info->SenseInfo,
+                        cmd->rq->sense_len);
+        } else
+                cmd->rq->sense_len = 0;
+
+        return error_count;
+}
+
 /* checks the status of the job and calls complete buffers to mark all
  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.
@@ -2343,109 +2409,99 @@ static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
 static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                                     int timeout)
 {
-        int status = 1;
         int retry_cmd = 0;
+        struct request *rq = cmd->rq;
+
+        rq->errors = 0;
 
         if (timeout)
-                status = 0;
+                rq->errors = 1;
 
-        if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
-                switch (cmd->err_info->CommandStatus) {
-                        unsigned char sense_key;
-                case CMD_TARGET_STATUS:
-                        status = 0;
+        if (cmd->err_info->CommandStatus == 0)  /* no error has occurred */
+                goto after_error_processing;
 
-                        if (cmd->err_info->ScsiStatus == 0x02) {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has CHECK CONDITION "
-                                       " byte 2 = 0x%x\n", cmd,
-                                       cmd->err_info->SenseInfo[2]
-                                    );
-                                /* check the sense key */
-                                sense_key = 0xf & cmd->err_info->SenseInfo[2];
-                                /* no status or recovered error */
-                                if ((sense_key == 0x0) || (sense_key == 0x1)) {
-                                        status = 1;
-                                }
-                        } else {
-                                printk(KERN_WARNING "cciss: cmd %p "
-                                       "has SCSI Status 0x%x\n",
-                                       cmd, cmd->err_info->ScsiStatus);
-                        }
-                        break;
-                case CMD_DATA_UNDERRUN:
+        switch (cmd->err_info->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                rq->errors = evaluate_target_status(cmd);
+                break;
+        case CMD_DATA_UNDERRUN:
+                if (blk_fs_request(cmd->rq)) {
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data underrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_DATA_OVERRUN:
+                        cmd->rq->data_len = cmd->err_info->ResidualCnt;
+                }
+                break;
+        case CMD_DATA_OVERRUN:
+                if (blk_fs_request(cmd->rq))
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data overrun "
                                "reported\n", cmd);
-                        break;
-                case CMD_INVALID:
-                        printk(KERN_WARNING "cciss: cmd %p is "
-                               "reported invalid\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_PROTOCOL_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p has "
-                               "protocol error \n", cmd);
-                        status = 0;
-                        break;
-                case CMD_HARDWARE_ERR:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               " hardware error\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_CONNECTION_LOST:
-                        printk(KERN_WARNING "cciss: cmd %p had "
-                               "connection lost\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORTED:
-                        printk(KERN_WARNING "cciss: cmd %p was "
-                               "aborted\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_ABORT_FAILED:
-                        printk(KERN_WARNING "cciss: cmd %p reports "
-                               "abort failed\n", cmd);
-                        status = 0;
-                        break;
-                case CMD_UNSOLICITED_ABORT:
-                        printk(KERN_WARNING "cciss%d: unsolicited "
-                               "abort %p\n", h->ctlr, cmd);
-                        if (cmd->retry_count < MAX_CMD_RETRIES) {
-                                retry_cmd = 1;
-                                printk(KERN_WARNING
-                                       "cciss%d: retrying %p\n", h->ctlr, cmd);
-                                cmd->retry_count++;
-                        } else
-                                printk(KERN_WARNING
-                                       "cciss%d: %p retried too "
-                                       "many times\n", h->ctlr, cmd);
-                        status = 0;
-                        break;
-                case CMD_TIMEOUT:
-                        printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
-                        status = 0;
-                        break;
-                default:
-                        printk(KERN_WARNING "cciss: cmd %p returned "
-                               "unknown status %x\n", cmd,
-                               cmd->err_info->CommandStatus);
-                        status = 0;
-                }
+                break;
+        case CMD_INVALID:
+                printk(KERN_WARNING "cciss: cmd %p is "
+                       "reported invalid\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_PROTOCOL_ERR:
+                printk(KERN_WARNING "cciss: cmd %p has "
+                       "protocol error \n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_HARDWARE_ERR:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       " hardware error\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_CONNECTION_LOST:
+                printk(KERN_WARNING "cciss: cmd %p had "
+                       "connection lost\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORTED:
+                printk(KERN_WARNING "cciss: cmd %p was "
+                       "aborted\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_ABORT_FAILED:
+                printk(KERN_WARNING "cciss: cmd %p reports "
+                       "abort failed\n", cmd);
+                rq->errors = 1;
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                printk(KERN_WARNING "cciss%d: unsolicited "
+                       "abort %p\n", h->ctlr, cmd);
+                if (cmd->retry_count < MAX_CMD_RETRIES) {
+                        retry_cmd = 1;
+                        printk(KERN_WARNING
+                               "cciss%d: retrying %p\n", h->ctlr, cmd);
+                        cmd->retry_count++;
+                } else
+                        printk(KERN_WARNING
+                               "cciss%d: %p retried too "
+                               "many times\n", h->ctlr, cmd);
+                rq->errors = 1;
+                break;
+        case CMD_TIMEOUT:
+                printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
+                rq->errors = 1;
+                break;
+        default:
+                printk(KERN_WARNING "cciss: cmd %p returned "
+                       "unknown status %x\n", cmd,
+                       cmd->err_info->CommandStatus);
+                rq->errors = 1;
         }
+
+after_error_processing:
+
         /* We need to return this command */
         if (retry_cmd) {
                 resend_cciss_cmd(h, cmd);
                 return;
         }
-
+        cmd->rq->data_len = 0;
         cmd->rq->completion_data = cmd;
-        cmd->rq->errors = status;
         blk_add_trace_rq(cmd->rq->q, cmd->rq, BLK_TA_COMPLETE);
         blk_complete_request(cmd->rq);
 }
@@ -2539,32 +2595,40 @@ static void do_cciss_request(request_queue_t *q)
 #endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
-        if(h->cciss_read == CCISS_READ_10) {
-                c->Request.CDB[1] = 0;
-                c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
-                c->Request.CDB[3] = (start_blk >> 16) & 0xff;
-                c->Request.CDB[4] = (start_blk >> 8) & 0xff;
-                c->Request.CDB[5] = start_blk & 0xff;
-                c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
-                c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
-                c->Request.CDB[8] = creq->nr_sectors & 0xff;
-                c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+        if (likely(blk_fs_request(creq))) {
+                if(h->cciss_read == CCISS_READ_10) {
+                        c->Request.CDB[1] = 0;
+                        c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+                        c->Request.CDB[3] = (start_blk >> 16) & 0xff;
+                        c->Request.CDB[4] = (start_blk >> 8) & 0xff;
+                        c->Request.CDB[5] = start_blk & 0xff;
+                        c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+                        c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
+                        c->Request.CDB[8] = creq->nr_sectors & 0xff;
+                        c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
+                } else {
+                        c->Request.CDBLen = 16;
+                        c->Request.CDB[1]= 0;
+                        c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
+                        c->Request.CDB[3]= (start_blk >> 48) & 0xff;
+                        c->Request.CDB[4]= (start_blk >> 40) & 0xff;
+                        c->Request.CDB[5]= (start_blk >> 32) & 0xff;
+                        c->Request.CDB[6]= (start_blk >> 24) & 0xff;
+                        c->Request.CDB[7]= (start_blk >> 16) & 0xff;
+                        c->Request.CDB[8]= (start_blk >>  8) & 0xff;
+                        c->Request.CDB[9]= start_blk & 0xff;
+                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
+                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
+                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
+                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                }
+        } else if (blk_pc_request(creq)) {
+                c->Request.CDBLen = creq->cmd_len;
+                memcpy(c->Request.CDB, creq->cmd, BLK_MAX_CDB);
         } else {
-                c->Request.CDBLen = 16;
-                c->Request.CDB[1]= 0;
-                c->Request.CDB[2]= (start_blk >> 56) & 0xff;    //MSB
-                c->Request.CDB[3]= (start_blk >> 48) & 0xff;
-                c->Request.CDB[4]= (start_blk >> 40) & 0xff;
-                c->Request.CDB[5]= (start_blk >> 32) & 0xff;
-                c->Request.CDB[6]= (start_blk >> 24) & 0xff;
-                c->Request.CDB[7]= (start_blk >> 16) & 0xff;
-                c->Request.CDB[8]= (start_blk >>  8) & 0xff;
-                c->Request.CDB[9]= start_blk & 0xff;
-                c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
-                c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
-                c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
-                c->Request.CDB[13]= creq->nr_sectors & 0xff;
-                c->Request.CDB[14] = c->Request.CDB[15] = 0;
+                printk(KERN_WARNING "cciss%d: bad request type %d\n", h->ctlr, creq->cmd_type);
+                BUG();
         }
 
         spin_lock_irq(q->queue_lock);
@@ -3405,13 +3469,39 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         return -1;
 }
 
-static void cciss_remove_one(struct pci_dev *pdev)
+static void cciss_shutdown(struct pci_dev *pdev)
 {
         ctlr_info_t *tmp_ptr;
-        int i, j;
+        int i;
         char flush_buf[4];
         int return_code;
 
+        tmp_ptr = pci_get_drvdata(pdev);
+        if (tmp_ptr == NULL)
+                return;
+        i = tmp_ptr->ctlr;
+        if (hba[i] == NULL)
+                return;
+
+        /* Turn board interrupts off  and send the flush cache command */
+        /* sendcmd will turn off interrupt, and send the flush...
+         * To write all data in the battery backed cache to disks */
+        memset(flush_buf, 0, 4);
+        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
+                              TYPE_CMD);
+        if (return_code == IO_OK) {
+                printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
+        } else {
+                printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
+        }
+        free_irq(hba[i]->intr[2], hba[i]);
+}
+
+static void __devexit cciss_remove_one(struct pci_dev *pdev)
+{
+        ctlr_info_t *tmp_ptr;
+        int i, j;
+
         if (pci_get_drvdata(pdev) == NULL) {
                 printk(KERN_ERR "cciss: Unable to remove device \n");
                 return;
@@ -3442,18 +3532,7 @@ static void cciss_remove_one(struct pci_dev *pdev)
 
         cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
 
-        /* Turn board interrupts off  and send the flush cache command */
-        /* sendcmd will turn off interrupt, and send the flush...
-         * To write all data in the battery backed cache to disks */
-        memset(flush_buf, 0, 4);
-        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
-                              TYPE_CMD);
-        if (return_code == IO_OK) {
-                printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
-        } else {
-                printk(KERN_WARNING "Error flushing cache on controller %d\n", i);
-        }
-        free_irq(hba[i]->intr[2], hba[i]);
+        cciss_shutdown(pdev);
 
 #ifdef CONFIG_PCI_MSI
         if (hba[i]->msix_vector)
@@ -3486,7 +3565,7 @@ static struct pci_driver cciss_pci_driver = {
         .probe = cciss_init_one,
         .remove = __devexit_p(cciss_remove_one),
         .id_table = cciss_pci_device_id,        /* id_table */
-        .shutdown = cciss_remove_one,
+        .shutdown = cciss_shutdown,
 };
 
 /*
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index bb15051ffbe0..90961a8ea895 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -35,7 +35,6 @@
 
 #include <asm/atomic.h>
 
-#include <scsi/scsi.h> 
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h> 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 5231ed7e723f..3587cb434371 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4334,7 +4334,10 @@ static int __init floppy_init(void)
                 if (err)
                         goto out_flush_work;
 
-                device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
+                err = device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
+                if (err)
+                        goto out_unreg_platform_dev;
+
                 /* to be cleaned up... */
                 disks[drive]->private_data = (void *)(long)drive;
                 disks[drive]->queue = floppy_queue;
@@ -4345,6 +4348,8 @@ static int __init floppy_init(void)
 
         return 0;
 
+out_unreg_platform_dev:
+        platform_device_unregister(&floppy_device[drive]);
 out_flush_work:
         flush_scheduled_work();
         if (usage_count)
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 0d4ccd4a0957..5526eadb6592 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -77,9 +77,8 @@
 
 #include <asm/uaccess.h>
 
-static int max_loop = 8;
-static struct loop_device *loop_dev;
-static struct gendisk **disks;
+static LIST_HEAD(loop_devices);
+static DEFINE_MUTEX(loop_devices_mutex);
 
 /*
  * Transfer functions
@@ -183,7 +182,7 @@ figure_loop_size(struct loop_device *lo)
         if (unlikely((loff_t)x != size))
                 return -EFBIG;
 
-        set_capacity(disks[lo->lo_number], x);
+        set_capacity(lo->lo_disk, x);
         return 0;                                       
 }
 
@@ -244,17 +243,13 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
                 transfer_result = lo_do_transfer(lo, WRITE, page, offset,
                                 bvec->bv_page, bv_offs, size, IV);
                 if (unlikely(transfer_result)) {
-                        char *kaddr;
-
                         /*
                          * The transfer failed, but we still write the data to
                          * keep prepare/commit calls balanced.
                          */
                         printk(KERN_ERR "loop: transfer error block %llu\n",
                                (unsigned long long)index);
-                        kaddr = kmap_atomic(page, KM_USER0);
-                        memset(kaddr + offset, 0, size);
-                        kunmap_atomic(kaddr, KM_USER0);
+                        zero_user_page(page, offset, size, KM_USER0);
                 }
                 flush_dcache_page(page);
                 ret = aops->commit_write(file, page, offset,
@@ -812,7 +807,7 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
         lo->lo_queue->queuedata = lo;
         lo->lo_queue->unplug_fn = loop_unplug;
 
-        set_capacity(disks[lo->lo_number], size);
+        set_capacity(lo->lo_disk, size);
         bd_set_size(bdev, size << 9);
 
         set_blocksize(bdev, lo_blocksize);
@@ -832,7 +827,7 @@ out_clr:
         lo->lo_device = NULL;
         lo->lo_backing_file = NULL;
         lo->lo_flags = 0;
-        set_capacity(disks[lo->lo_number], 0);
+        set_capacity(lo->lo_disk, 0);
         invalidate_bdev(bdev);
         bd_set_size(bdev, 0);
         mapping_set_gfp_mask(mapping, lo->old_gfp_mask);
@@ -918,7 +913,7 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
         memset(lo->lo_crypt_name, 0, LO_NAME_SIZE);
         memset(lo->lo_file_name, 0, LO_NAME_SIZE);
         invalidate_bdev(bdev);
-        set_capacity(disks[lo->lo_number], 0);
+        set_capacity(lo->lo_disk, 0);
         bd_set_size(bdev, 0);
         mapping_set_gfp_mask(filp->f_mapping, gfp);
         lo->lo_state = Lo_unbound;
@@ -1357,8 +1352,9 @@ static struct block_device_operations lo_fops = {
 /*
  * And now the modules code and kernel interface.
  */
+static int max_loop;
 module_param(max_loop, int, 0);
-MODULE_PARM_DESC(max_loop, "Maximum number of loop devices (1-256)");
+MODULE_PARM_DESC(max_loop, "obsolete, loop device is created on-demand");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_BLOCKDEV_MAJOR(LOOP_MAJOR);
 
@@ -1383,7 +1379,7 @@ int loop_unregister_transfer(int number)
 
         xfer_funcs[n] = NULL;
 
-        for (lo = &loop_dev[0]; lo < &loop_dev[max_loop]; lo++) {
+        list_for_each_entry(lo, &loop_devices, lo_list) {
                 mutex_lock(&lo->lo_ctl_mutex);
 
                 if (lo->lo_encryption == xfer)
@@ -1398,91 +1394,100 @@ int loop_unregister_transfer(int number)
 EXPORT_SYMBOL(loop_register_transfer);
 EXPORT_SYMBOL(loop_unregister_transfer);
 
-static int __init loop_init(void)
+static struct loop_device *loop_init_one(int i)
 {
-        int     i;
+        struct loop_device *lo;
+        struct gendisk *disk;
 
-        if (max_loop < 1 || max_loop > 256) {
-                printk(KERN_WARNING "loop: invalid max_loop (must be between"
-                                    " 1 and 256), using default (8)\n");
-                max_loop = 8;
+        list_for_each_entry(lo, &loop_devices, lo_list) {
+                if (lo->lo_number == i)
+                        return lo;
         }
 
-        if (register_blkdev(LOOP_MAJOR, "loop"))
-                return -EIO;
-
-        loop_dev = kmalloc(max_loop * sizeof(struct loop_device), GFP_KERNEL);
-        if (!loop_dev)
-                goto out_mem1;
-        memset(loop_dev, 0, max_loop * sizeof(struct loop_device));
+        lo = kzalloc(sizeof(*lo), GFP_KERNEL);
+        if (!lo)
+                goto out;
 
-        disks = kmalloc(max_loop * sizeof(struct gendisk *), GFP_KERNEL);
-        if (!disks)
-                goto out_mem2;
+        lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
+        if (!lo->lo_queue)
+                goto out_free_dev;
+
+        disk = lo->lo_disk = alloc_disk(1);
+        if (!disk)
+                goto out_free_queue;
+
+        mutex_init(&lo->lo_ctl_mutex);
+        lo->lo_number           = i;
+        lo->lo_thread           = NULL;
+        init_waitqueue_head(&lo->lo_event);
+        spin_lock_init(&lo->lo_lock);
+        disk->major             = LOOP_MAJOR;
+        disk->first_minor       = i;
+        disk->fops              = &lo_fops;
+        disk->private_data      = lo;
+        disk->queue             = lo->lo_queue;
+        sprintf(disk->disk_name, "loop%d", i);
+        add_disk(disk);
+        list_add_tail(&lo->lo_list, &loop_devices);
+        return lo;
+
+out_free_queue:
+        blk_cleanup_queue(lo->lo_queue);
+out_free_dev:
+        kfree(lo);
+out:
+        return NULL;
+}
 
-        for (i = 0; i < max_loop; i++) {
-                disks[i] = alloc_disk(1);
-                if (!disks[i])
-                        goto out_mem3;
-        }
+static void loop_del_one(struct loop_device *lo)
+{
+        del_gendisk(lo->lo_disk);
+        blk_cleanup_queue(lo->lo_queue);
+        put_disk(lo->lo_disk);
+        list_del(&lo->lo_list);
+        kfree(lo);
+}
 
-        for (i = 0; i < max_loop; i++) {
-                struct loop_device *lo = &loop_dev[i];
-                struct gendisk *disk = disks[i];
-
-                memset(lo, 0, sizeof(*lo));
-                lo->lo_queue = blk_alloc_queue(GFP_KERNEL);
-                if (!lo->lo_queue)
-                        goto out_mem4;
-                mutex_init(&lo->lo_ctl_mutex);
-                lo->lo_number = i;
-                lo->lo_thread = NULL;
-                init_waitqueue_head(&lo->lo_event);
-                spin_lock_init(&lo->lo_lock);
-                disk->major = LOOP_MAJOR;
-                disk->first_minor = i;
-                disk->fops = &lo_fops;
-                sprintf(disk->disk_name, "loop%d", i);
-                disk->private_data = lo;
-                disk->queue = lo->lo_queue;
-        }
+static struct kobject *loop_probe(dev_t dev, int *part, void *data)
+{
+        struct loop_device *lo;
+        struct kobject *kobj;
 
-        /* We cannot fail after we call this, so another loop!*/
-        for (i = 0; i < max_loop; i++)
-                add_disk(disks[i]);
-        printk(KERN_INFO "loop: loaded (max %d devices)\n", max_loop);
-        return 0;
+        mutex_lock(&loop_devices_mutex);
+        lo = loop_init_one(dev & MINORMASK);
+        kobj = lo ? get_disk(lo->lo_disk) : ERR_PTR(-ENOMEM);
+        mutex_unlock(&loop_devices_mutex);
 
-out_mem4:
-        while (i--)
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-        i = max_loop;
-out_mem3:
-        while (i--)
-                put_disk(disks[i]);
-        kfree(disks);
-out_mem2:
-        kfree(loop_dev);
-out_mem1:
-        unregister_blkdev(LOOP_MAJOR, "loop");
-        printk(KERN_ERR "loop: ran out of memory\n");
-        return -ENOMEM;
+        *part = 0;
+        return kobj;
 }
 
-static void loop_exit(void)
+static int __init loop_init(void)
 {
-        int i;
+        if (register_blkdev(LOOP_MAJOR, "loop"))
+                return -EIO;
+        blk_register_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS,
+                                  THIS_MODULE, loop_probe, NULL, NULL);
+
+        if (max_loop) {
+                printk(KERN_INFO "loop: the max_loop option is obsolete "
+                                 "and will be removed in March 2008\n");
 
-        for (i = 0; i < max_loop; i++) {
-                del_gendisk(disks[i]);
-                blk_cleanup_queue(loop_dev[i].lo_queue);
-                put_disk(disks[i]);
         }
+        printk(KERN_INFO "loop: module loaded\n");
+        return 0;
+}
+
+static void __exit loop_exit(void)
+{
+        struct loop_device *lo, *next;
+
+        list_for_each_entry_safe(lo, next, &loop_devices, lo_list)
+                loop_del_one(lo);
+
+        blk_unregister_region(MKDEV(LOOP_MAJOR, 0), 1UL << MINORBITS);
         if (unregister_blkdev(LOOP_MAJOR, "loop"))
                 printk(KERN_WARNING "loop: cannot unregister blkdev\n");
-
-        kfree(disks);
-        kfree(loop_dev);
 }
 
 module_init(loop_init);
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 090796bef78f..069ae39a9cd9 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -366,20 +366,25 @@ static struct disk_attribute pid_attr = {
         .show = pid_show,
 };
 
-static void nbd_do_it(struct nbd_device *lo)
+static int nbd_do_it(struct nbd_device *lo)
 {
         struct request *req;
+        int ret;
 
         BUG_ON(lo->magic != LO_MAGIC);
 
         lo->pid = current->pid;
-        sysfs_create_file(&lo->disk->kobj, &pid_attr.attr);
+        ret = sysfs_create_file(&lo->disk->kobj, &pid_attr.attr);
+        if (ret) {
+                printk(KERN_ERR "nbd: sysfs_create_file failed!");
+                return ret;
+        }
 
         while ((req = nbd_read_stat(lo)) != NULL)
                 nbd_end_request(req);
 
         sysfs_remove_file(&lo->disk->kobj, &pid_attr.attr);
-        return;
+        return 0;
 }
 
 static void nbd_clear_que(struct nbd_device *lo)
@@ -569,7 +574,9 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         case NBD_DO_IT:
                 if (!lo->file)
                         return -EINVAL;
-                nbd_do_it(lo);
+                error = nbd_do_it(lo);
+                if (error)
+                        return error;
                 /* on return tidy up in case we have a signal */
                 /* Forcibly shutdown the socket causing all listeners
                  * to error
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 43d4ebcb3b44..a1512da32410 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -151,7 +151,7 @@ static int ramdisk_commit_write(struct file *file, struct page *page,
 }
 
 /*
- * ->writepage to the the blockdev's mapping has to redirty the page so that the
+ * ->writepage to the blockdev's mapping has to redirty the page so that the
  * VM doesn't go and steal it.  We return AOP_WRITEPAGE_ACTIVATE so that the VM
  * won't try to (pointlessly) write the page again for a while.
  *
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 5872036e8ae6..6f5d6203d725 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -44,7 +44,6 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
 #include <linux/timer.h>
 #include <linux/pci.h>
 #include <linux/slab.h>