12 files changed, 92 insertions, 80 deletions

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index 70eaa5c7ac08..21097a39a057 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -3471,7 +3471,7 @@ static inline boolean DAC960_ProcessCompletedRequest(DAC960_Command_T *Command,
 
          if (!end_that_request_first(Request, UpToDate, Command->BlockCount)) {
 
-                end_that_request_last(Request);
+                end_that_request_last(Request, UpToDate);
 
                 if (Command->Completion) {
                         complete(Command->Completion);
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index c4b9d2adfc08..139cbba76180 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -117,7 +117,7 @@ config BLK_DEV_XD
 
 config PARIDE
         tristate "Parallel port IDE device support"
-        depends on PARPORT
+        depends on PARPORT_PC
         ---help---
           There are many external CD-ROM and disk devices that connect through
           your computer's parallel port. Most of them are actually IDE devices
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index c3441b3f086e..d2815b7a9150 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2310,7 +2310,7 @@ static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
         printk("Done with %p\n", cmd->rq);
 #endif /* CCISS_DEBUG */ 
 
-        end_that_request_last(cmd->rq);
+        end_that_request_last(cmd->rq, status ? 1 : -EIO);
         cmd_free(h,cmd,1);
 }
 
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index cf1822a6361c..9bddb6874873 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -1036,7 +1036,7 @@ static inline void complete_command(cmdlist_t *cmd, int timeout)
         complete_buffers(cmd->rq->bio, ok);
 
         DBGPX(printk("Done with %p\n", cmd->rq););
-        end_that_request_last(cmd->rq);
+        end_that_request_last(cmd->rq, ok ? 1 : -EIO);
 }
 
 /*
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index f7e765a1d313..a5b857c5c4b8 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2301,7 +2301,7 @@ static void floppy_end_request(struct request *req, int uptodate)
         add_disk_randomness(req->rq_disk);
         floppy_off((long)req->rq_disk->private_data);
         blkdev_dequeue_request(req);
-        end_that_request_last(req);
+        end_that_request_last(req, uptodate);
 
         /* We're done with the request */
         current_req = NULL;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 96c664af8d06..a452b13620a2 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -213,7 +213,7 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
         struct address_space_operations *aops = mapping->a_ops;
         pgoff_t index;
         unsigned offset, bv_offs;
-        int len, ret = 0;
+        int len, ret;
 
         down(&mapping->host->i_sem);
         index = pos >> PAGE_CACHE_SHIFT;
@@ -232,9 +232,15 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
                 page = grab_cache_page(mapping, index);
                 if (unlikely(!page))
                         goto fail;
-                if (unlikely(aops->prepare_write(file, page, offset,
-                                offset + size)))
+                ret = aops->prepare_write(file, page, offset,
+                                          offset + size);
+                if (unlikely(ret)) {
+                        if (ret == AOP_TRUNCATED_PAGE) {
+                                page_cache_release(page);
+                                continue;
+                        }
                         goto unlock;
+                }
                 transfer_result = lo_do_transfer(lo, WRITE, page, offset,
                                 bvec->bv_page, bv_offs, size, IV);
                 if (unlikely(transfer_result)) {
@@ -251,9 +257,15 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
                         kunmap_atomic(kaddr, KM_USER0);
                 }
                 flush_dcache_page(page);
-                if (unlikely(aops->commit_write(file, page, offset,
-                                offset + size)))
+                ret = aops->commit_write(file, page, offset,
+                                         offset + size);
+                if (unlikely(ret)) {
+                        if (ret == AOP_TRUNCATED_PAGE) {
+                                page_cache_release(page);
+                                continue;
+                        }
                         goto unlock;
+                }
                 if (unlikely(transfer_result))
                         goto unlock;
                 bv_offs += size;
@@ -264,6 +276,7 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
                 unlock_page(page);
                 page_cache_release(page);
         }
+        ret = 0;
 out:
         up(&mapping->host->i_sem);
         return ret;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 9e268ddedfbd..33d6f237b2ed 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -54,11 +54,15 @@
 #include <linux/errno.h>
 #include <linux/file.h>
 #include <linux/ioctl.h>
+#include <linux/compiler.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
 #include <net/sock.h>
 
 #include <linux/devfs_fs_kernel.h>
 
 #include <asm/uaccess.h>
+#include <asm/system.h>
 #include <asm/types.h>
 
 #include <linux/nbd.h>
@@ -136,7 +140,7 @@ static void nbd_end_request(struct request *req)
 
         spin_lock_irqsave(q->queue_lock, flags);
         if (!end_that_request_first(req, uptodate, req->nr_sectors)) {
-                end_that_request_last(req);
+                end_that_request_last(req, uptodate);
         }
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
@@ -230,14 +234,6 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
         request.len = htonl(size);
         memcpy(request.handle, &req, sizeof(req));
 
-        down(&lo->tx_lock);
-
-        if (!sock || !lo->sock) {
-                printk(KERN_ERR "%s: Attempted send on closed socket\n",
-                                lo->disk->disk_name);
-                goto error_out;
-        }
-
         dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
                         lo->disk->disk_name, req,
                         nbdcmd_to_ascii(nbd_cmd(req)),
@@ -276,11 +272,9 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
                         }
                 }
         }
-        up(&lo->tx_lock);
         return 0;
 
 error_out:
-        up(&lo->tx_lock);
         return 1;
 }
 
@@ -289,9 +283,14 @@ static struct request *nbd_find_request(struct nbd_device *lo, char *handle)
         struct request *req;
         struct list_head *tmp;
         struct request *xreq;
+        int err;
 
         memcpy(&xreq, handle, sizeof(xreq));
 
+        err = wait_event_interruptible(lo->active_wq, lo->active_req != xreq);
+        if (unlikely(err))
+                goto out;
+
         spin_lock(&lo->queue_lock);
         list_for_each(tmp, &lo->queue_head) {
                 req = list_entry(tmp, struct request, queuelist);
@@ -302,7 +301,11 @@ static struct request *nbd_find_request(struct nbd_device *lo, char *handle)
                 return req;
         }
         spin_unlock(&lo->queue_lock);
-        return NULL;
+
+        err = -ENOENT;
+
+out:
+        return ERR_PTR(err);
 }
 
 static inline int sock_recv_bvec(struct socket *sock, struct bio_vec *bvec)
@@ -331,7 +334,11 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
                 goto harderror;
         }
         req = nbd_find_request(lo, reply.handle);
-        if (req == NULL) {
+        if (unlikely(IS_ERR(req))) {
+                result = PTR_ERR(req);
+                if (result != -ENOENT)
+                        goto harderror;
+
                 printk(KERN_ERR "%s: Unexpected reply (%p)\n",
                                 lo->disk->disk_name, reply.handle);
                 result = -EBADR;
@@ -395,19 +402,24 @@ static void nbd_clear_que(struct nbd_device *lo)
 
         BUG_ON(lo->magic != LO_MAGIC);
 
-        do {
-                req = NULL;
-                spin_lock(&lo->queue_lock);
-                if (!list_empty(&lo->queue_head)) {
-                        req = list_entry(lo->queue_head.next, struct request, queuelist);
-                        list_del_init(&req->queuelist);
-                }
-                spin_unlock(&lo->queue_lock);
-                if (req) {
-                        req->errors++;
-                        nbd_end_request(req);
-                }
-        } while (req);
+        /*
+         * Because we have set lo->sock to NULL under the tx_lock, all
+         * modifications to the list must have completed by now.  For
+         * the same reason, the active_req must be NULL.
+         *
+         * As a consequence, we don't need to take the spin lock while
+         * purging the list here.
+         */
+        BUG_ON(lo->sock);
+        BUG_ON(lo->active_req);
+
+        while (!list_empty(&lo->queue_head)) {
+                req = list_entry(lo->queue_head.next, struct request,
+                                 queuelist);
+                list_del_init(&req->queuelist);
+                req->errors++;
+                nbd_end_request(req);
+        }
 }
 
 /*
@@ -435,11 +447,6 @@ static void do_nbd_request(request_queue_t * q)
 
                 BUG_ON(lo->magic != LO_MAGIC);
 
-                if (!lo->file) {
-                        printk(KERN_ERR "%s: Request when not-ready\n",
-                                        lo->disk->disk_name);
-                        goto error_out;
-                }
                 nbd_cmd(req) = NBD_CMD_READ;
                 if (rq_data_dir(req) == WRITE) {
                         nbd_cmd(req) = NBD_CMD_WRITE;
@@ -453,32 +460,34 @@ static void do_nbd_request(request_queue_t * q)
                 req->errors = 0;
                 spin_unlock_irq(q->queue_lock);
 
-                spin_lock(&lo->queue_lock);
-
-                if (!lo->file) {
-                        spin_unlock(&lo->queue_lock);
-                        printk(KERN_ERR "%s: failed between accept and semaphore, file lost\n",
-                                        lo->disk->disk_name);
+                down(&lo->tx_lock);
+                if (unlikely(!lo->sock)) {
+                        up(&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;
                 }
 
-                list_add(&req->queuelist, &lo->queue_head);
-                spin_unlock(&lo->queue_lock);
+                lo->active_req = req;
 
                 if (nbd_send_req(lo, req) != 0) {
                         printk(KERN_ERR "%s: Request send failed\n",
                                         lo->disk->disk_name);
-                        if (nbd_find_request(lo, (char *)&req) != NULL) {
-                                /* we still own req */
-                                req->errors++;
-                                nbd_end_request(req);
-                        } else /* we're racing with nbd_clear_que */
-                                printk(KERN_DEBUG "nbd: can't find req\n");
+                        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;
+                up(&lo->tx_lock);
+                wake_up_all(&lo->active_wq);
+
                 spin_lock_irq(q->queue_lock);
                 continue;
 
@@ -529,17 +538,10 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                 down(&lo->tx_lock);
                 lo->sock = NULL;
                 up(&lo->tx_lock);
-                spin_lock(&lo->queue_lock);
                 file = lo->file;
                 lo->file = NULL;
-                spin_unlock(&lo->queue_lock);
                 nbd_clear_que(lo);
-                spin_lock(&lo->queue_lock);
-                if (!list_empty(&lo->queue_head)) {
-                        printk(KERN_ERR "nbd: disconnect: some requests are in progress -> please try again.\n");
-                        error = -EBUSY;
-                }
-                spin_unlock(&lo->queue_lock);
+                BUG_ON(!list_empty(&lo->queue_head));
                 if (file)
                         fput(file);
                 return error;
@@ -598,24 +600,19 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                         lo->sock = NULL;
                 }
                 up(&lo->tx_lock);
-                spin_lock(&lo->queue_lock);
                 file = lo->file;
                 lo->file = NULL;
-                spin_unlock(&lo->queue_lock);
                 nbd_clear_que(lo);
                 printk(KERN_WARNING "%s: queue cleared\n", lo->disk->disk_name);
                 if (file)
                         fput(file);
                 return lo->harderror;
         case NBD_CLEAR_QUE:
-                down(&lo->tx_lock);
-                if (lo->sock) {
-                        up(&lo->tx_lock);
-                        return 0; /* probably should be error, but that would
-                                   * break "nbd-client -d", so just return 0 */
-                }
-                up(&lo->tx_lock);
-                nbd_clear_que(lo);
+                /*
+                 * This is for compatibility only.  The queue is always cleared
+                 * by NBD_DO_IT or NBD_CLEAR_SOCK.
+                 */
+                BUG_ON(!lo->sock && !list_empty(&lo->queue_head));
                 return 0;
         case NBD_PRINT_DEBUG:
                 printk(KERN_INFO "%s: next = %p, prev = %p, head = %p\n",
@@ -688,6 +685,7 @@ static int __init nbd_init(void)
                 spin_lock_init(&nbd_dev[i].queue_lock);
                 INIT_LIST_HEAD(&nbd_dev[i].queue_head);
                 init_MUTEX(&nbd_dev[i].tx_lock);
+                init_waitqueue_head(&nbd_dev[i].active_wq);
                 nbd_dev[i].blksize = 1024;
                 nbd_dev[i].bytesize = 0x7ffffc00ULL << 10; /* 2TB */
                 disk->major = NBD_MAJOR;
diff --git a/drivers/block/paride/Kconfig b/drivers/block/paride/Kconfig
index 17ff40561257..c0d2854dd097 100644
--- a/drivers/block/paride/Kconfig
+++ b/drivers/block/paride/Kconfig
@@ -4,11 +4,12 @@
 # PARIDE doesn't need PARPORT, but if PARPORT is configured as a module,
 # PARIDE must also be a module.  The bogus CONFIG_PARIDE_PARPORT option
 # controls the choices given to the user ...
+# PARIDE only supports PC style parports. Tough for USB or other parports...
 config PARIDE_PARPORT
         tristate
         depends on PARIDE!=n
-        default m if PARPORT=m
-        default y if PARPORT!=m
+        default m if PARPORT_PC=m
+        default y if PARPORT_PC!=m
 
 comment "Parallel IDE high-level drivers"
         depends on PARIDE
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 68c60a5bcdab..ffd6abd6d5a0 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -154,7 +154,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
- * VM doesn't go and steal it.  We return WRITEPAGE_ACTIVATE so that the VM
+ * 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.
  *
  * Really, these pages should not be on the LRU at all.
@@ -165,7 +165,7 @@ static int ramdisk_writepage(struct page *page, struct writeback_control *wbc)
                 make_page_uptodate(page);
         SetPageDirty(page);
         if (wbc->for_reclaim)
-                return WRITEPAGE_ACTIVATE;
+                return AOP_WRITEPAGE_ACTIVATE;
         unlock_page(page);
         return 0;
 }
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 1ded3b433459..9251f4131b53 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -770,7 +770,7 @@ static inline void carm_end_request_queued(struct carm_host *host,
         rc = end_that_request_first(req, uptodate, req->hard_nr_sectors);
         assert(rc == 0);
 
-        end_that_request_last(req);
+        end_that_request_last(req, uptodate);
 
         rc = carm_put_request(host, crq);
         assert(rc == 0);
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 10740a065088..a05fe5843e6c 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -951,7 +951,7 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
 static void ub_end_rq(struct request *rq, int uptodate)
 {
         end_that_request_first(rq, uptodate, rq->hard_nr_sectors);
-        end_that_request_last(rq);
+        end_that_request_last(rq, uptodate);
 }
 
 static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index 2d518aa2720a..063f0304a163 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -305,7 +305,7 @@ static void viodasd_end_request(struct request *req, int uptodate,
         if (end_that_request_first(req, uptodate, num_sectors))
                 return;
         add_disk_randomness(req->rq_disk);
-        end_that_request_last(req);
+        end_that_request_last(req, uptodate);
 }
 
 /*