Merge branch 'for-2.6.30' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.30' of git://git.kernel.dk/linux-2.6-block:
  Get rid of pdflush_operation() in emergency sync and remount
  btrfs: get rid of current_is_pdflush() in btrfs_btree_balance_dirty
  Move the default_backing_dev_info out of readahead.c and into backing-dev.c
  block: Repeated lines in switching-sched.txt
  bsg: Remove bogus check against request_queue->max_sectors
  block: WARN in __blk_put_request() for potential bio leak
  loop: fix circular locking in loop_clr_fd()
  loop: support barrier writes
  bsg: add support for tail queuing
  cpqarray: enable bus mastering
  block: genhd.h cleanup patch
  block: add private bio_set for bio integrity allocations
  block: genhd.h comment needs updating
  block: get rid of unused blkdev_free_rq() define
  block: remove various blk_queue_*() setting functions in blk_init_queue_node()
  cciss: add BUILD_BUG_ON() for catching bad CommandList_struct alignment
  block: don't create bio_vec slabs of less than the inline number
  block: cleanup bio_alloc_bioset()

3 files changed, 52 insertions, 4 deletions

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 4f9b6d792017..5d0e135824f9 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -3898,6 +3898,13 @@ static struct pci_driver cciss_pci_driver = {
  */
 static int __init cciss_init(void)
 {
+        /*
+         * The hardware requires that commands are aligned on a 64-bit
+         * boundary. Given that we use pci_alloc_consistent() to allocate an
+         * array of them, the size must be a multiple of 8 bytes.
+         */
+        BUILD_BUG_ON(sizeof(CommandList_struct) % 8);
+
         printk(KERN_INFO DRIVER_NAME "\n");
 
         /* Register for our PCI devices */
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 5d39df14ed90..ca268ca11159 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -617,6 +617,7 @@ static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
         int i;
 
         c->pci_dev = pdev;
+        pci_set_master(pdev);
         if (pci_enable_device(pdev)) {
                 printk(KERN_ERR "cpqarray: Unable to Enable PCI device\n");
                 return -1;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index bf0345577672..2621ed2ce6d2 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -474,10 +474,35 @@ static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
         int ret;
 
         pos = ((loff_t) bio->bi_sector << 9) + lo->lo_offset;
-        if (bio_rw(bio) == WRITE)
+
+        if (bio_rw(bio) == WRITE) {
+                int barrier = bio_barrier(bio);
+                struct file *file = lo->lo_backing_file;
+
+                if (barrier) {
+                        if (unlikely(!file->f_op->fsync)) {
+                                ret = -EOPNOTSUPP;
+                                goto out;
+                        }
+
+                        ret = vfs_fsync(file, file->f_path.dentry, 0);
+                        if (unlikely(ret)) {
+                                ret = -EIO;
+                                goto out;
+                        }
+                }
+
                 ret = lo_send(lo, bio, pos);
-        else
+
+                if (barrier && !ret) {
+                        ret = vfs_fsync(file, file->f_path.dentry, 0);
+                        if (unlikely(ret))
+                                ret = -EIO;
+                }
+        } else
                 ret = lo_receive(lo, bio, lo->lo_blocksize, pos);
+
+out:
         return ret;
 }
 
@@ -826,6 +851,9 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
         lo->lo_queue->queuedata = lo;
         lo->lo_queue->unplug_fn = loop_unplug;
 
+        if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)
+                blk_queue_ordered(lo->lo_queue, QUEUE_ORDERED_DRAIN, NULL);
+
         set_capacity(lo->lo_disk, size);
         bd_set_size(bdev, size << 9);
 
@@ -941,11 +969,18 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
                 bd_set_size(bdev, 0);
         mapping_set_gfp_mask(filp->f_mapping, gfp);
         lo->lo_state = Lo_unbound;
-        fput(filp);
         /* This is safe: open() is still holding a reference. */
         module_put(THIS_MODULE);
         if (max_part > 0)
                 ioctl_by_bdev(bdev, BLKRRPART, 0);
+        mutex_unlock(&lo->lo_ctl_mutex);
+        /*
+         * Need not hold lo_ctl_mutex to fput backing file.
+         * Calling fput holding lo_ctl_mutex triggers a circular
+         * lock dependency possibility warning as fput can take
+         * bd_mutex which is usually taken before lo_ctl_mutex.
+         */
+        fput(filp);
         return 0;
 }
 
@@ -1163,7 +1198,7 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
         struct loop_device *lo = bdev->bd_disk->private_data;
         int err;
 
-        mutex_lock(&lo->lo_ctl_mutex);
+        mutex_lock_nested(&lo->lo_ctl_mutex, 1);
         switch (cmd) {
         case LOOP_SET_FD:
                 err = loop_set_fd(lo, mode, bdev, arg);
@@ -1172,7 +1207,10 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
                 err = loop_change_fd(lo, bdev, arg);
                 break;
         case LOOP_CLR_FD:
+                /* loop_clr_fd would have unlocked lo_ctl_mutex on success */
                 err = loop_clr_fd(lo, bdev);
+                if (!err)
+                        goto out_unlocked;
                 break;
         case LOOP_SET_STATUS:
                 err = loop_set_status_old(lo, (struct loop_info __user *) arg);
@@ -1190,6 +1228,8 @@ static int lo_ioctl(struct block_device *bdev, fmode_t mode,
                 err = lo->ioctl ? lo->ioctl(lo, cmd, arg) : -EINVAL;
         }
         mutex_unlock(&lo->lo_ctl_mutex);
+
+out_unlocked:
         return err;
 }