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

* 'for-2.6.36' of git://git.kernel.dk/linux-2.6-block: (149 commits)
  block: make sure that REQ_* types are seen even with CONFIG_BLOCK=n
  xen-blkfront: fix missing out label
  blkdev: fix blkdev_issue_zeroout return value
  block: update request stacking methods to support discards
  block: fix missing export of blk_types.h
  writeback: fix bad _bh spinlock nesting
  drbd: revert "delay probes", feature is being re-implemented differently
  drbd: Initialize all members of sync_conf to their defaults [Bugz 315]
  drbd: Disable delay probes for the upcomming release
  writeback: cleanup bdi_register
  writeback: add new tracepoints
  writeback: remove unnecessary init_timer call
  writeback: optimize periodic bdi thread wakeups
  writeback: prevent unnecessary bdi threads wakeups
  writeback: move bdi threads exiting logic to the forker thread
  writeback: restructure bdi forker loop a little
  writeback: move last_active to bdi
  writeback: do not remove bdi from bdi_list
  writeback: simplify bdi code a little
  writeback: do not lose wake-ups in bdi threads
  ...

Fixed up pretty trivial conflicts in drivers/block/virtio_blk.c and
drivers/scsi/scsi_error.c as per Jens.

diff --cc drivers/ata/libata-scsi.c
Simple merge

diff --cc drivers/block/cciss.c
Simple merge

diff --cc drivers/block/drbd/drbd_receiver.c
Simple merge

diff --cc drivers/block/nbd.c
Simple merge

diff --cc drivers/block/virtio_blk.c
index 23b7c48,7b0f7b6..2aafafc
--- 1/drivers/block/virtio_blk.c
--- 2/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@@ -377,32 -377,11 +388,31 @@@ static int __devinit virtblk_probe(stru
        vblk->disk->driverfs_dev = &vdev->dev;
        index++;
  
 -      /* If barriers are supported, tell block layer that queue is ordered */
 -      if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
 +      if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH)) {
 +              /*
 +               * If the FLUSH feature is supported we do have support for
 +               * flushing a volatile write cache on the host.  Use that
 +               * to implement write barrier support.
 +               */
-               blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH,
-                                 virtblk_prepare_flush);
+               blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH);
 -      else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))
 +      } else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER)) {
 +              /*
 +               * If the BARRIER feature is supported the host expects us
 +               * to order request by tags.  This implies there is not
 +               * volatile write cache on the host, and that the host
 +               * never re-orders outstanding I/O.  This feature is not
 +               * useful for real life scenarious and deprecated.
 +               */
-               blk_queue_ordered(q, QUEUE_ORDERED_TAG, NULL);
+               blk_queue_ordered(q, QUEUE_ORDERED_TAG);
 +      } else {
 +              /*
 +               * If the FLUSH feature is not supported we must assume that
 +               * the host does not perform any kind of volatile write
 +               * caching. We still need to drain the queue to provider
 +               * proper barrier semantics.
 +               */
-               blk_queue_ordered(q, QUEUE_ORDERED_DRAIN, NULL);
++              blk_queue_ordered(q, QUEUE_ORDERED_DRAIN);
 +      }
  
        /* If disk is read-only in the host, the guest should obey */
        if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))

diff --cc drivers/block/xen-blkfront.c
Simple merge

diff --cc drivers/ide/ide-cd.c
index 2de76cc,5108e97..31fc769
--- 1/drivers/ide/ide-cd.c
--- 2/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@@ -686,11 -681,10 +688,11 @@@ out_end
                }
  
                if (uptodate == 0 && rq->bio)
 -                      ide_cd_error_cmd(drive, cmd);
 +                      if (ide_cd_error_cmd(drive, cmd))
 +                              return ide_stopped;
  
                /* make sure it's fully ended */
-               if (blk_fs_request(rq) == 0) {
+               if (rq->cmd_type != REQ_TYPE_FS) {
                        rq->resid_len -= cmd->nbytes - cmd->nleft;
                        if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE))
                                rq->resid_len += cmd->last_xfer_len;

diff --cc drivers/ide/ide-gd.c
Simple merge

diff --cc drivers/mtd/mtd_blkdevs.c
Simple merge

diff --cc drivers/scsi/scsi_error.c
index 2bf9846,2768bf6..bbbc186
--- 1/drivers/scsi/scsi_error.c
--- 2/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@@ -307,33 -307,7 +307,33 @@@ static int scsi_check_sense(struct scsi
                    (sshdr.asc == 0x04) && (sshdr.ascq == 0x02))
                        return FAILED;
  
 -              return NEEDS_RETRY;
 +              if (sshdr.asc == 0x3f && sshdr.ascq == 0x0e)
 +                      scmd_printk(KERN_WARNING, scmd,
 +                                  "Warning! Received an indication that the "
 +                                  "LUN assignments on this target have "
 +                                  "changed. The Linux SCSI layer does not "
 +                                  "automatically remap LUN assignments.\n");
 +              else if (sshdr.asc == 0x3f)
 +                      scmd_printk(KERN_WARNING, scmd,
 +                                  "Warning! Received an indication that the "
 +                                  "operating parameters on this target have "
 +                                  "changed. The Linux SCSI layer does not "
 +                                  "automatically adjust these parameters.\n");
 +
-               if (blk_barrier_rq(scmd->request))
++              if (scmd->request->cmd_flags & REQ_HARDBARRIER)
 +                      /*
 +                       * barrier requests should always retry on UA
 +                       * otherwise block will get a spurious error
 +                       */
 +                      return NEEDS_RETRY;
 +              else
 +                      /*
 +                       * for normal (non barrier) commands, pass the
 +                       * UA upwards for a determination in the
 +                       * completion functions
 +                       */
 +                      return SUCCESS;
 +
                /* these three are not supported */
        case COPY_ABORTED:
        case VOLUME_OVERFLOW:

diff --cc drivers/scsi/sd.c
index cc8a1d1,108daea..8e2e893
--- 1/drivers/scsi/sd.c
--- 2/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@@ -2367,11 -2399,10 +2408,12 @@@ static int sd_remove(struct device *dev
  {
        struct scsi_disk *sdkp;
  
 -      async_synchronize_full();
        sdkp = dev_get_drvdata(dev);
 +      scsi_autopm_get_device(sdkp->device);
 +
 +      async_synchronize_full();
        blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
+       blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
        device_del(&sdkp->dev);
        del_gendisk(sdkp->disk);
        sd_shutdown(dev);

diff --cc drivers/staging/hv/blkvsc_drv.c
Simple merge

diff --cc fs/block_dev.c
Simple merge

diff --cc fs/btrfs/inode.c
Simple merge

diff --cc fs/fs-writeback.c
Simple merge

diff --cc fs/gfs2/ops_fstype.c
Simple merge

diff --cc include/linux/Kbuild
Simple merge

diff --cc include/linux/fs.h
index a8ccf85,c539112..1542e0e
--- 1/include/linux/fs.h
--- 2/include/linux/fs.h
+++ b/include/linux/fs.h
@@@ -2263,9 -2267,18 +2265,8 @@@ static inline int xip_truncate_page(str
  #endif
  
  #ifdef CONFIG_BLOCK
- struct bio;
  typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
                            loff_t file_offset);
 -void dio_end_io(struct bio *bio, int error);
 -
 -ssize_t __blockdev_direct_IO_newtrunc(int rw, struct kiocb *iocb, struct inode *inode,
 -      struct block_device *bdev, const struct iovec *iov, loff_t offset,
 -      unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 -      dio_submit_t submit_io, int lock_type);
 -ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 -      struct block_device *bdev, const struct iovec *iov, loff_t offset,
 -      unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 -      dio_submit_t submit_io, int lock_type);
  
  enum {
        /* need locking between buffered and direct access */

diff --cc mm/page-writeback.c
Simple merge