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.

2 files changed, 64 insertions, 18 deletions

diff --git a/kernel/power/block_io.c b/kernel/power/block_io.c
index 97024fd40cd5..83bbc7c02df9 100644
--- a/kernel/power/block_io.c
+++ b/kernel/power/block_io.c
@@ -28,7 +28,7 @@
 static int submit(int rw, struct block_device *bdev, sector_t sector,
                 struct page *page, struct bio **bio_chain)
 {
-        const int bio_rw = rw | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
+        const int bio_rw = rw | REQ_SYNC | REQ_UNPLUG;
         struct bio *bio;
 
         bio = bio_alloc(__GFP_WAIT | __GFP_HIGH, 1);
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 638711c17504..82499a5bdcb7 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -169,9 +169,12 @@ static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,
 static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),
                                  BLK_TC_ACT(BLK_TC_WRITE) };
 
+#define BLK_TC_HARDBARRIER      BLK_TC_BARRIER
+#define BLK_TC_RAHEAD           BLK_TC_AHEAD
+
 /* The ilog2() calls fall out because they're constant */
-#define MASK_TC_BIT(rw, __name) ((rw & (1 << BIO_RW_ ## __name)) << \
-          (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - BIO_RW_ ## __name))
+#define MASK_TC_BIT(rw, __name) ((rw & REQ_ ## __name) << \
+          (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - __REQ_ ## __name))
 
 /*
  * The worker for the various blk_add_trace*() types. Fills out a
@@ -194,9 +197,9 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
                 return;
 
         what |= ddir_act[rw & WRITE];
-        what |= MASK_TC_BIT(rw, BARRIER);
-        what |= MASK_TC_BIT(rw, SYNCIO);
-        what |= MASK_TC_BIT(rw, AHEAD);
+        what |= MASK_TC_BIT(rw, HARDBARRIER);
+        what |= MASK_TC_BIT(rw, SYNC);
+        what |= MASK_TC_BIT(rw, RAHEAD);
         what |= MASK_TC_BIT(rw, META);
         what |= MASK_TC_BIT(rw, DISCARD);
 
@@ -549,6 +552,41 @@ int blk_trace_setup(struct request_queue *q, char *name, dev_t dev,
 }
 EXPORT_SYMBOL_GPL(blk_trace_setup);
 
+#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
+static int compat_blk_trace_setup(struct request_queue *q, char *name,
+                                  dev_t dev, struct block_device *bdev,
+                                  char __user *arg)
+{
+        struct blk_user_trace_setup buts;
+        struct compat_blk_user_trace_setup cbuts;
+        int ret;
+
+        if (copy_from_user(&cbuts, arg, sizeof(cbuts)))
+                return -EFAULT;
+
+        buts = (struct blk_user_trace_setup) {
+                .act_mask = cbuts.act_mask,
+                .buf_size = cbuts.buf_size,
+                .buf_nr = cbuts.buf_nr,
+                .start_lba = cbuts.start_lba,
+                .end_lba = cbuts.end_lba,
+                .pid = cbuts.pid,
+        };
+        memcpy(&buts.name, &cbuts.name, 32);
+
+        ret = do_blk_trace_setup(q, name, dev, bdev, &buts);
+        if (ret)
+                return ret;
+
+        if (copy_to_user(arg, &buts.name, 32)) {
+                blk_trace_remove(q);
+                return -EFAULT;
+        }
+
+        return 0;
+}
+#endif
+
 int blk_trace_startstop(struct request_queue *q, int start)
 {
         int ret;
@@ -601,6 +639,7 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
         if (!q)
                 return -ENXIO;
 
+        lock_kernel();
         mutex_lock(&bdev->bd_mutex);
 
         switch (cmd) {
@@ -608,6 +647,12 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
                 bdevname(bdev, b);
                 ret = blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
                 break;
+#if defined(CONFIG_COMPAT) && defined(CONFIG_X86_64)
+        case BLKTRACESETUP32:
+                bdevname(bdev, b);
+                ret = compat_blk_trace_setup(q, b, bdev->bd_dev, bdev, arg);
+                break;
+#endif
         case BLKTRACESTART:
                 start = 1;
         case BLKTRACESTOP:
@@ -622,6 +667,7 @@ int blk_trace_ioctl(struct block_device *bdev, unsigned cmd, char __user *arg)
         }
 
         mutex_unlock(&bdev->bd_mutex);
+        unlock_kernel();
         return ret;
 }
 
@@ -661,10 +707,10 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
         if (likely(!bt))
                 return;
 
-        if (blk_discard_rq(rq))
-                rw |= (1 << BIO_RW_DISCARD);
+        if (rq->cmd_flags & REQ_DISCARD)
+                rw |= REQ_DISCARD;
 
-        if (blk_pc_request(rq)) {
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
                 what |= BLK_TC_ACT(BLK_TC_PC);
                 __blk_add_trace(bt, 0, blk_rq_bytes(rq), rw,
                                 what, rq->errors, rq->cmd_len, rq->cmd);
@@ -925,7 +971,7 @@ void blk_add_driver_data(struct request_queue *q,
         if (likely(!bt))
                 return;
 
-        if (blk_pc_request(rq))
+        if (rq->cmd_type == REQ_TYPE_BLOCK_PC)
                 __blk_add_trace(bt, 0, blk_rq_bytes(rq), 0,
                                 BLK_TA_DRV_DATA, rq->errors, len, data);
         else
@@ -1730,7 +1776,7 @@ void blk_dump_cmd(char *buf, struct request *rq)
         int len = rq->cmd_len;
         unsigned char *cmd = rq->cmd;
 
-        if (!blk_pc_request(rq)) {
+        if (rq->cmd_type != REQ_TYPE_BLOCK_PC) {
                 buf[0] = '\0';
                 return;
         }
@@ -1755,20 +1801,20 @@ void blk_fill_rwbs(char *rwbs, u32 rw, int bytes)
 
         if (rw & WRITE)
                 rwbs[i++] = 'W';
-        else if (rw & 1 << BIO_RW_DISCARD)
+        else if (rw & REQ_DISCARD)
                 rwbs[i++] = 'D';
         else if (bytes)
                 rwbs[i++] = 'R';
         else
                 rwbs[i++] = 'N';
 
-        if (rw & 1 << BIO_RW_AHEAD)
+        if (rw & REQ_RAHEAD)
                 rwbs[i++] = 'A';
-        if (rw & 1 << BIO_RW_BARRIER)
+        if (rw & REQ_HARDBARRIER)
                 rwbs[i++] = 'B';
-        if (rw & 1 << BIO_RW_SYNCIO)
+        if (rw & REQ_SYNC)
                 rwbs[i++] = 'S';
-        if (rw & 1 << BIO_RW_META)
+        if (rw & REQ_META)
                 rwbs[i++] = 'M';
 
         rwbs[i] = '\0';
@@ -1779,8 +1825,8 @@ void blk_fill_rwbs_rq(char *rwbs, struct request *rq)
         int rw = rq->cmd_flags & 0x03;
         int bytes;
 
-        if (blk_discard_rq(rq))
-                rw |= (1 << BIO_RW_DISCARD);
+        if (rq->cmd_flags & REQ_DISCARD)
+                rw |= REQ_DISCARD;
 
         bytes = blk_rq_bytes(rq);