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

* 'for-3.2/core' of git://git.kernel.dk/linux-block: (29 commits)
  block: don't call blk_drain_queue() if elevator is not up
  blk-throttle: use queue_is_locked() instead of lockdep_is_held()
  blk-throttle: Take blkcg->lock while traversing blkcg->policy_list
  blk-throttle: Free up policy node associated with deleted rule
  block: warn if tag is greater than real_max_depth.
  block: make gendisk hold a reference to its queue
  blk-flush: move the queue kick into
  blk-flush: fix invalid BUG_ON in blk_insert_flush
  block: Remove the control of complete cpu from bio.
  block: fix a typo in the blk-cgroup.h file
  block: initialize the bounce pool if high memory may be added later
  block: fix request_queue lifetime handling by making blk_queue_cleanup() properly shutdown
  block: drop @tsk from attempt_plug_merge() and explain sync rules
  block: make get_request[_wait]() fail if queue is dead
  block: reorganize throtl_get_tg() and blk_throtl_bio()
  block: reorganize queue draining
  block: drop unnecessary blk_get/put_queue() in scsi_cmd_ioctl() and blk_get_tg()
  block: pass around REQ_* flags instead of broken down booleans during request alloc/free
  block: move blk_throtl prototypes to block/blk.h
  block: fix genhd refcounting in blkio_policy_parse_and_set()
  ...

Fix up trivial conflicts due to "mddev_t" -> "struct mddev" conversion
and making the request functions be of type "void" instead of "int" in
 - drivers/md/{faulty.c,linear.c,md.c,md.h,multipath.c,raid0.c,raid1.c,raid10.c,raid5.c}
 - drivers/staging/zram/zram_drv.c

8 files changed, 46 insertions, 143 deletions

diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index 528f6318ded1..167ba0af47f5 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -159,7 +159,7 @@ aoeblk_release(struct gendisk *disk, fmode_t mode)
         return 0;
 }
 
-static int
+static void
 aoeblk_make_request(struct request_queue *q, struct bio *bio)
 {
         struct sk_buff_head queue;
@@ -172,25 +172,25 @@ aoeblk_make_request(struct request_queue *q, struct bio *bio)
         if (bio == NULL) {
                 printk(KERN_ERR "aoe: bio is NULL\n");
                 BUG();
-                return 0;
+                return;
         }
         d = bio->bi_bdev->bd_disk->private_data;
         if (d == NULL) {
                 printk(KERN_ERR "aoe: bd_disk->private_data is NULL\n");
                 BUG();
                 bio_endio(bio, -ENXIO);
-                return 0;
+                return;
         } else if (bio->bi_io_vec == NULL) {
                 printk(KERN_ERR "aoe: bi_io_vec is NULL\n");
                 BUG();
                 bio_endio(bio, -ENXIO);
-                return 0;
+                return;
         }
         buf = mempool_alloc(d->bufpool, GFP_NOIO);
         if (buf == NULL) {
                 printk(KERN_INFO "aoe: buf allocation failure\n");
                 bio_endio(bio, -ENOMEM);
-                return 0;
+                return;
         }
         memset(buf, 0, sizeof(*buf));
         INIT_LIST_HEAD(&buf->bufs);
@@ -211,7 +211,7 @@ aoeblk_make_request(struct request_queue *q, struct bio *bio)
                 spin_unlock_irqrestore(&d->lock, flags);
                 mempool_free(buf, d->bufpool);
                 bio_endio(bio, -ENXIO);
-                return 0;
+                return;
         }
 
         list_add_tail(&buf->bufs, &d->bufq);
@@ -222,8 +222,6 @@ aoeblk_make_request(struct request_queue *q, struct bio *bio)
 
         spin_unlock_irqrestore(&d->lock, flags);
         aoenet_xmit(&queue);
-
-        return 0;
 }
 
 static int
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index dba1c32e1ddf..d22119d49e53 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -323,7 +323,7 @@ out:
         return err;
 }
 
-static int brd_make_request(struct request_queue *q, struct bio *bio)
+static void brd_make_request(struct request_queue *q, struct bio *bio)
 {
         struct block_device *bdev = bio->bi_bdev;
         struct brd_device *brd = bdev->bd_disk->private_data;
@@ -359,8 +359,6 @@ static int brd_make_request(struct request_queue *q, struct bio *bio)
 
 out:
         bio_endio(bio, err);
-
-        return 0;
 }
 
 #ifdef CONFIG_BLK_DEV_XIP
diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index 1706d60b8c99..9cf20355ceec 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -1506,7 +1506,7 @@ extern void drbd_free_mdev(struct drbd_conf *mdev);
 extern int proc_details;
 
 /* drbd_req */
-extern int drbd_make_request(struct request_queue *q, struct bio *bio);
+extern void drbd_make_request(struct request_queue *q, struct bio *bio);
 extern int drbd_read_remote(struct drbd_conf *mdev, struct drbd_request *req);
 extern int drbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bvm, struct bio_vec *bvec);
 extern int is_valid_ar_handle(struct drbd_request *, sector_t);
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index 3424d675b769..4a0f314086e5 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -1073,7 +1073,7 @@ static int drbd_fail_request_early(struct drbd_conf *mdev, int is_write)
         return 0;
 }
 
-int drbd_make_request(struct request_queue *q, struct bio *bio)
+void drbd_make_request(struct request_queue *q, struct bio *bio)
 {
         unsigned int s_enr, e_enr;
         struct drbd_conf *mdev = (struct drbd_conf *) q->queuedata;
@@ -1081,7 +1081,7 @@ int drbd_make_request(struct request_queue *q, struct bio *bio)
 
         if (drbd_fail_request_early(mdev, bio_data_dir(bio) & WRITE)) {
                 bio_endio(bio, -EPERM);
-                return 0;
+                return;
         }
 
         start_time = jiffies;
@@ -1100,7 +1100,8 @@ int drbd_make_request(struct request_queue *q, struct bio *bio)
 
         if (likely(s_enr == e_enr)) {
                 inc_ap_bio(mdev, 1);
-                return drbd_make_request_common(mdev, bio, start_time);
+                drbd_make_request_common(mdev, bio, start_time);
+                return;
         }
 
         /* can this bio be split generically?
@@ -1148,7 +1149,6 @@ int drbd_make_request(struct request_queue *q, struct bio *bio)
 
                 bio_pair_release(bp);
         }
-        return 0;
 }
 
 /* This is called by bio_add_page().  With this function we reduce
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 4720c7ade0ae..c77983ea86c8 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -203,74 +203,6 @@ lo_do_transfer(struct loop_device *lo, int cmd,
 }
 
 /**
- * do_lo_send_aops - helper for writing data to a loop device
- *
- * This is the fast version for backing filesystems which implement the address
- * space operations write_begin and write_end.
- */
-static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
-                loff_t pos, struct page *unused)
-{
-        struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */
-        struct address_space *mapping = file->f_mapping;
-        pgoff_t index;
-        unsigned offset, bv_offs;
-        int len, ret;
-
-        mutex_lock(&mapping->host->i_mutex);
-        index = pos >> PAGE_CACHE_SHIFT;
-        offset = pos & ((pgoff_t)PAGE_CACHE_SIZE - 1);
-        bv_offs = bvec->bv_offset;
-        len = bvec->bv_len;
-        while (len > 0) {
-                sector_t IV;
-                unsigned size, copied;
-                int transfer_result;
-                struct page *page;
-                void *fsdata;
-
-                IV = ((sector_t)index << (PAGE_CACHE_SHIFT - 9))+(offset >> 9);
-                size = PAGE_CACHE_SIZE - offset;
-                if (size > len)
-                        size = len;
-
-                ret = pagecache_write_begin(file, mapping, pos, size, 0,
-                                                        &page, &fsdata);
-                if (ret)
-                        goto fail;
-
-                file_update_time(file);
-
-                transfer_result = lo_do_transfer(lo, WRITE, page, offset,
-                                bvec->bv_page, bv_offs, size, IV);
-                copied = size;
-                if (unlikely(transfer_result))
-                        copied = 0;
-
-                ret = pagecache_write_end(file, mapping, pos, size, copied,
-                                                        page, fsdata);
-                if (ret < 0 || ret != copied)
-                        goto fail;
-
-                if (unlikely(transfer_result))
-                        goto fail;
-
-                bv_offs += copied;
-                len -= copied;
-                offset = 0;
-                index++;
-                pos += copied;
-        }
-        ret = 0;
-out:
-        mutex_unlock(&mapping->host->i_mutex);
-        return ret;
-fail:
-        ret = -1;
-        goto out;
-}
-
-/**
  * __do_lo_send_write - helper for writing data to a loop device
  *
  * This helper just factors out common code between do_lo_send_direct_write()
@@ -297,10 +229,8 @@ static int __do_lo_send_write(struct file *file,
 /**
  * do_lo_send_direct_write - helper for writing data to a loop device
  *
- * This is the fast, non-transforming version for backing filesystems which do
- * not implement the address space operations write_begin and write_end.
- * It uses the write file operation which should be present on all writeable
- * filesystems.
+ * This is the fast, non-transforming version that does not need double
+ * buffering.
  */
 static int do_lo_send_direct_write(struct loop_device *lo,
                 struct bio_vec *bvec, loff_t pos, struct page *page)
@@ -316,15 +246,9 @@ static int do_lo_send_direct_write(struct loop_device *lo,
 /**
  * do_lo_send_write - helper for writing data to a loop device
  *
- * This is the slow, transforming version for filesystems which do not
- * implement the address space operations write_begin and write_end.  It
- * uses the write file operation which should be present on all writeable
- * filesystems.
- *
- * Using fops->write is slower than using aops->{prepare,commit}_write in the
- * transforming case because we need to double buffer the data as we cannot do
- * the transformations in place as we do not have direct access to the
- * destination pages of the backing file.
+ * This is the slow, transforming version that needs to double buffer the
+ * data as it cannot do the transformations in place without having direct
+ * access to the destination pages of the backing file.
  */
 static int do_lo_send_write(struct loop_device *lo, struct bio_vec *bvec,
                 loff_t pos, struct page *page)
@@ -350,17 +274,16 @@ static int lo_send(struct loop_device *lo, struct bio *bio, loff_t pos)
         struct page *page = NULL;
         int i, ret = 0;
 
-        do_lo_send = do_lo_send_aops;
-        if (!(lo->lo_flags & LO_FLAGS_USE_AOPS)) {
+        if (lo->transfer != transfer_none) {
+                page = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
+                if (unlikely(!page))
+                        goto fail;
+                kmap(page);
+                do_lo_send = do_lo_send_write;
+        } else {
                 do_lo_send = do_lo_send_direct_write;
-                if (lo->transfer != transfer_none) {
-                        page = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
-                        if (unlikely(!page))
-                                goto fail;
-                        kmap(page);
-                        do_lo_send = do_lo_send_write;
-                }
         }
+
         bio_for_each_segment(bvec, bio, i) {
                 ret = do_lo_send(lo, bvec, pos, page);
                 if (ret < 0)
@@ -514,7 +437,7 @@ static struct bio *loop_get_bio(struct loop_device *lo)
         return bio_list_pop(&lo->lo_bio_list);
 }
 
-static int loop_make_request(struct request_queue *q, struct bio *old_bio)
+static void loop_make_request(struct request_queue *q, struct bio *old_bio)
 {
         struct loop_device *lo = q->queuedata;
         int rw = bio_rw(old_bio);
@@ -532,12 +455,11 @@ static int loop_make_request(struct request_queue *q, struct bio *old_bio)
         loop_add_bio(lo, old_bio);
         wake_up(&lo->lo_event);
         spin_unlock_irq(&lo->lo_lock);
-        return 0;
+        return;
 
 out:
         spin_unlock_irq(&lo->lo_lock);
         bio_io_error(old_bio);
-        return 0;
 }
 
 struct switch_request {
@@ -849,35 +771,23 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
         mapping = file->f_mapping;
         inode = mapping->host;
 
-        if (!(file->f_mode & FMODE_WRITE))
-                lo_flags |= LO_FLAGS_READ_ONLY;
-
         error = -EINVAL;
-        if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) {
-                const struct address_space_operations *aops = mapping->a_ops;
-
-                if (aops->write_begin)
-                        lo_flags |= LO_FLAGS_USE_AOPS;
-                if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write)
-                        lo_flags |= LO_FLAGS_READ_ONLY;
+        if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
+                goto out_putf;
 
-                lo_blocksize = S_ISBLK(inode->i_mode) ?
-                        inode->i_bdev->bd_block_size : PAGE_SIZE;
+        if (!(file->f_mode & FMODE_WRITE) || !(mode & FMODE_WRITE) ||
+            !file->f_op->write)
+                lo_flags |= LO_FLAGS_READ_ONLY;
 
-                error = 0;
-        } else {
-                goto out_putf;
-        }
+        lo_blocksize = S_ISBLK(inode->i_mode) ?
+                inode->i_bdev->bd_block_size : PAGE_SIZE;
 
+        error = -EFBIG;
         size = get_loop_size(lo, file);
-
-        if ((loff_t)(sector_t)size != size) {
-                error = -EFBIG;
+        if ((loff_t)(sector_t)size != size)
                 goto out_putf;
-        }
 
-        if (!(mode & FMODE_WRITE))
-                lo_flags |= LO_FLAGS_READ_ONLY;
+        error = 0;
 
         set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index e133f094ab08..a63b0a2b7805 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2444,7 +2444,7 @@ static void pkt_end_io_read_cloned(struct bio *bio, int err)
         pkt_bio_finished(pd);
 }
 
-static int pkt_make_request(struct request_queue *q, struct bio *bio)
+static void pkt_make_request(struct request_queue *q, struct bio *bio)
 {
         struct pktcdvd_device *pd;
         char b[BDEVNAME_SIZE];
@@ -2473,7 +2473,7 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
                 cloned_bio->bi_end_io = pkt_end_io_read_cloned;
                 pd->stats.secs_r += bio->bi_size >> 9;
                 pkt_queue_bio(pd, cloned_bio);
-                return 0;
+                return;
         }
 
         if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
@@ -2509,7 +2509,7 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
                         pkt_make_request(q, &bp->bio1);
                         pkt_make_request(q, &bp->bio2);
                         bio_pair_release(bp);
-                        return 0;
+                        return;
                 }
         }
 
@@ -2533,7 +2533,7 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
                                 }
                                 spin_unlock(&pkt->lock);
                                 spin_unlock(&pd->cdrw.active_list_lock);
-                                return 0;
+                                return;
                         } else {
                                 blocked_bio = 1;
                         }
@@ -2584,10 +2584,9 @@ static int pkt_make_request(struct request_queue *q, struct bio *bio)
                  */
                 wake_up(&pd->wqueue);
         }
-        return 0;
+        return;
 end_io:
         bio_io_error(bio);
-        return 0;
 }
 
 
diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
index b3bdb8af89cf..7fad7af87eb2 100644
--- a/drivers/block/ps3vram.c
+++ b/drivers/block/ps3vram.c
@@ -596,7 +596,7 @@ out:
         return next;
 }
 
-static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
+static void ps3vram_make_request(struct request_queue *q, struct bio *bio)
 {
         struct ps3_system_bus_device *dev = q->queuedata;
         struct ps3vram_priv *priv = ps3_system_bus_get_drvdata(dev);
@@ -610,13 +610,11 @@ static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
         spin_unlock_irq(&priv->lock);
 
         if (busy)
-                return 0;
+                return;
 
         do {
                 bio = ps3vram_do_bio(dev, bio);
         } while (bio);
-
-        return 0;
 }
 
 static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index 031ca720d926..aa2712060bfb 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -513,7 +513,7 @@ static void process_page(unsigned long data)
         }
 }
 
-static int mm_make_request(struct request_queue *q, struct bio *bio)
+static void mm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct cardinfo *card = q->queuedata;
         pr_debug("mm_make_request %llu %u\n",
@@ -525,7 +525,7 @@ static int mm_make_request(struct request_queue *q, struct bio *bio)
         card->biotail = &bio->bi_next;
         spin_unlock_irq(&card->lock);
 
-        return 0;
+        return;
 }
 
 static irqreturn_t mm_interrupt(int irq, void *__card)