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

* 'for-2.6.31' of git://git.kernel.dk/linux-2.6-block: (153 commits)
  block: add request clone interface (v2)
  floppy: fix hibernation
  ramdisk: remove long-deprecated "ramdisk=" boot-time parameter
  fs/bio.c: add missing __user annotation
  block: prevent possible io_context->refcount overflow
  Add serial number support for virtio_blk, V4a
  block: Add missing bounce_pfn stacking and fix comments
  Revert "block: Fix bounce limit setting in DM"
  cciss: decode unit attention in SCSI error handling code
  cciss: Remove no longer needed sendcmd reject processing code
  cciss: change SCSI error handling routines to work with interrupts enabled.
  cciss: separate error processing and command retrying code in sendcmd_withirq_core()
  cciss: factor out fix target status processing code from sendcmd functions
  cciss: simplify interface of sendcmd() and sendcmd_withirq()
  cciss: factor out core of sendcmd_withirq() for use by SCSI error handling code
  cciss: Use schedule_timeout_uninterruptible in SCSI error handling code
  block: needs to set the residual length of a bidi request
  Revert "block: implement blkdev_readpages"
  block: Fix bounce limit setting in DM
  Removed reference to non-existing file Documentation/PCI/PCI-DMA-mapping.txt
  ...

Manually fix conflicts with tracing updates in:
	block/blk-sysfs.c
	drivers/ide/ide-atapi.c
	drivers/ide/ide-cd.c
	drivers/ide/ide-floppy.c
	drivers/ide/ide-tape.c
	include/trace/events/block.h
	kernel/trace/blktrace.c

diff --cc block/blk-core.c
Simple merge

diff --cc block/blk-sysfs.c
index 26f9ec2,9337e17..b1cd040
--- 1/block/blk-sysfs.c
--- 2/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@@ -390,15 -428,8 +429,11 @@@ int blk_register_queue(struct gendisk *
        if (WARN_ON(!q))
                return -ENXIO;
  
 -      ret = kobject_add(&q->kobj, kobject_get(&disk_to_dev(disk)->kobj),
 -                        "%s", "queue");
 +      ret = blk_trace_init_sysfs(dev);
 +      if (ret)
 +              return ret;
 +
-       if (!q->request_fn)
-               return 0;
- 
-       ret = kobject_add(&q->kobj, kobject_get(&dev->kobj),
-                         "%s", "queue");
++      ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
        if (ret < 0)
                return ret;
  

diff --cc block/bsg.c
index dd81be4,2d746e3..5358f9a
--- 1/block/bsg.c
--- 2/block/bsg.c
+++ b/block/bsg.c
@@@ -446,15 -445,14 +446,15 @@@ static int blk_complete_sgv4_hdr_rq(str
        }
  
        if (rq->next_rq) {
-               hdr->dout_resid = rq->data_len;
-               hdr->din_resid = rq->next_rq->data_len;
+               hdr->dout_resid = rq->resid_len;
+               hdr->din_resid = rq->next_rq->resid_len;
                blk_rq_unmap_user(bidi_bio);
 +              rq->next_rq->bio = NULL;
                blk_put_request(rq->next_rq);
        } else if (rq_data_dir(rq) == READ)
-               hdr->din_resid = rq->data_len;
+               hdr->din_resid = rq->resid_len;
        else
-               hdr->dout_resid = rq->data_len;
+               hdr->dout_resid = rq->resid_len;
  
        /*
         * If the request generated a negative error number, return it

diff --cc block/compat_ioctl.c
Simple merge

diff --cc block/elevator.c
index e220f0c,a029cfe..ca86192
--- 1/block/elevator.c
--- 2/block/elevator.c
+++ b/block/elevator.c
@@@ -51,9 -52,11 +51,8 @@@ static const int elv_hash_shift = 6
  #define ELV_HASH_FN(sec)      \
                (hash_long(ELV_HASH_BLOCK((sec)), elv_hash_shift))
  #define ELV_HASH_ENTRIES      (1 << elv_hash_shift)
- #define rq_hash_key(rq)               ((rq)->sector + (rq)->nr_sectors)
- #define ELV_ON_HASH(rq)               (!hlist_unhashed(&(rq)->hash))
+ #define rq_hash_key(rq)               (blk_rq_pos(rq) + blk_rq_sectors(rq))
  
 -DEFINE_TRACE(block_rq_insert);
 -DEFINE_TRACE(block_rq_issue);
 -
  /*
   * Query io scheduler to see if the current process issuing bio may be
   * merged with rq.

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

diff --cc drivers/ide/ide-tape.c
index 203bbea,683ff37..d9764f0
--- 1/drivers/ide/ide-tape.c
--- 2/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@@ -892,7 -892,6 +892,7 @@@ static int idetape_queue_rw_tail(ide_dr
        rq->cmd_type = REQ_TYPE_SPECIAL;
        rq->cmd[13] = cmd;
        rq->rq_disk = tape->disk;
-       rq->sector = tape->first_frame;
++      rq->__sector = tape->first_frame;
  
        if (size) {
                ret = blk_rq_map_kern(drive->queue, rq, tape->buf, size,

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

diff --cc drivers/md/bitmap.c
Simple merge

diff --cc drivers/md/md.c
Simple merge

diff --cc drivers/md/raid5.c
Simple merge

diff --cc drivers/scsi/sg.c
Simple merge

diff --cc fs/bio.c
Simple merge

diff --cc fs/buffer.c
Simple merge

diff --cc fs/ext3/super.c
Simple merge

diff --cc fs/ext4/super.c
index c191d0f,a30549f..f016707
--- 1/fs/ext4/super.c
--- 2/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@@ -3035,10 -2962,10 +3035,10 @@@ static journal_t *ext4_get_dev_journal(
        }
  
        blocksize = sb->s_blocksize;
-       hblock = bdev_hardsect_size(bdev);
+       hblock = bdev_logical_block_size(bdev);
        if (blocksize < hblock) {
 -              printk(KERN_ERR
 -                      "EXT4-fs: blocksize too small for journal device.\n");
 +              ext4_msg(sb, KERN_ERR,
 +                      "blocksize too small for journal device");
                goto out_bdev;
        }
  

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

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

diff --cc include/trace/events/block.h
index 53effd4,0000000..d6b05f4
mode 100644,000000..100644
--- 1/include/trace/events/block.h
--- /dev/null
+++ b/include/trace/events/block.h
@@@ -1,498 -1,0 +1,493 @@@
-               __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-               __entry->nr_sector = blk_pc_request(rq) ?
-                                               0 : rq->hard_nr_sectors;
 +#if !defined(_TRACE_BLOCK_H) || defined(TRACE_HEADER_MULTI_READ)
 +#define _TRACE_BLOCK_H
 +
 +#include <linux/blktrace_api.h>
 +#include <linux/blkdev.h>
 +#include <linux/tracepoint.h>
 +
 +#undef TRACE_SYSTEM
 +#define TRACE_SYSTEM block
 +
 +TRACE_EVENT(block_rq_abort,
 +
 +      TP_PROTO(struct request_queue *q, struct request *rq),
 +
 +      TP_ARGS(q, rq),
 +
 +      TP_STRUCT__entry(
 +              __field(  dev_t,        dev                     )
 +              __field(  sector_t,     sector                  )
 +              __field(  unsigned int, nr_sector               )
 +              __field(  int,          errors                  )
 +              __array(  char,         rwbs,   6               )
 +              __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-               __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-               __entry->nr_sector = blk_pc_request(rq) ?
-                                               0 : rq->hard_nr_sectors;
-               __entry->bytes     = blk_pc_request(rq) ? rq->data_len : 0;
++              __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
++              __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
 +              __entry->errors    = rq->errors;
 +
 +              blk_fill_rwbs_rq(__entry->rwbs, rq);
 +              blk_dump_cmd(__get_str(cmd), rq);
 +      ),
 +
 +      TP_printk("%d,%d %s (%s) %llu + %u [%d]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev),
 +                __entry->rwbs, __get_str(cmd),
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->errors)
 +);
 +
 +TRACE_EVENT(block_rq_insert,
 +
 +      TP_PROTO(struct request_queue *q, struct request *rq),
 +
 +      TP_ARGS(q, rq),
 +
 +      TP_STRUCT__entry(
 +              __field(  dev_t,        dev                     )
 +              __field(  sector_t,     sector                  )
 +              __field(  unsigned int, nr_sector               )
 +              __field(  unsigned int, bytes                   )
 +              __array(  char,         rwbs,   6               )
 +              __array(  char,         comm,   TASK_COMM_LEN   )
 +              __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-               __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-               __entry->nr_sector = blk_pc_request(rq) ?
-                                               0 : rq->hard_nr_sectors;
-               __entry->bytes     = blk_pc_request(rq) ? rq->data_len : 0;
++              __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
++              __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
++              __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
 +
 +              blk_fill_rwbs_rq(__entry->rwbs, rq);
 +              blk_dump_cmd(__get_str(cmd), rq);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev),
 +                __entry->rwbs, __entry->bytes, __get_str(cmd),
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_rq_issue,
 +
 +      TP_PROTO(struct request_queue *q, struct request *rq),
 +
 +      TP_ARGS(q, rq),
 +
 +      TP_STRUCT__entry(
 +              __field(  dev_t,        dev                     )
 +              __field(  sector_t,     sector                  )
 +              __field(  unsigned int, nr_sector               )
 +              __field(  unsigned int, bytes                   )
 +              __array(  char,         rwbs,   6               )
 +              __array(  char,         comm,   TASK_COMM_LEN   )
 +              __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-               __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-               __entry->nr_sector = blk_pc_request(rq) ?
-                                               0 : rq->hard_nr_sectors;
++              __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
++              __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
++              __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
 +
 +              blk_fill_rwbs_rq(__entry->rwbs, rq);
 +              blk_dump_cmd(__get_str(cmd), rq);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %u (%s) %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev),
 +                __entry->rwbs, __entry->bytes, __get_str(cmd),
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_rq_requeue,
 +
 +      TP_PROTO(struct request_queue *q, struct request *rq),
 +
 +      TP_ARGS(q, rq),
 +
 +      TP_STRUCT__entry(
 +              __field(  dev_t,        dev                     )
 +              __field(  sector_t,     sector                  )
 +              __field(  unsigned int, nr_sector               )
 +              __field(  int,          errors                  )
 +              __array(  char,         rwbs,   6               )
 +              __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-               __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-               __entry->nr_sector = blk_pc_request(rq) ?
-                                               0 : rq->hard_nr_sectors;
++              __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
++              __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
 +              __entry->errors    = rq->errors;
 +
 +              blk_fill_rwbs_rq(__entry->rwbs, rq);
 +              blk_dump_cmd(__get_str(cmd), rq);
 +      ),
 +
 +      TP_printk("%d,%d %s (%s) %llu + %u [%d]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev),
 +                __entry->rwbs, __get_str(cmd),
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->errors)
 +);
 +
 +TRACE_EVENT(block_rq_complete,
 +
 +      TP_PROTO(struct request_queue *q, struct request *rq),
 +
 +      TP_ARGS(q, rq),
 +
 +      TP_STRUCT__entry(
 +              __field(  dev_t,        dev                     )
 +              __field(  sector_t,     sector                  )
 +              __field(  unsigned int, nr_sector               )
 +              __field(  int,          errors                  )
 +              __array(  char,         rwbs,   6               )
 +              __dynamic_array( char,  cmd,    blk_cmd_buf_len(rq)     )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
++              __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
++              __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
 +              __entry->errors    = rq->errors;
 +
 +              blk_fill_rwbs_rq(__entry->rwbs, rq);
 +              blk_dump_cmd(__get_str(cmd), rq);
 +      ),
 +
 +      TP_printk("%d,%d %s (%s) %llu + %u [%d]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev),
 +                __entry->rwbs, __get_str(cmd),
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->errors)
 +);
 +TRACE_EVENT(block_bio_bounce,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio),
 +
 +      TP_ARGS(q, bio),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned int,  nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_bio_complete,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio),
 +
 +      TP_ARGS(q, bio),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev             )
 +              __field( sector_t,      sector          )
 +              __field( unsigned,      nr_sector       )
 +              __field( int,           error           )
 +              __array( char,          rwbs,   6       )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%d]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->error)
 +);
 +
 +TRACE_EVENT(block_bio_backmerge,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio),
 +
 +      TP_ARGS(q, bio),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned int,  nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_bio_frontmerge,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio),
 +
 +      TP_ARGS(q, bio),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned,      nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_bio_queue,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio),
 +
 +      TP_ARGS(q, bio),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned int,  nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_getrq,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
 +
 +      TP_ARGS(q, bio, rw),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned int,  nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +        ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio ? bio->bi_bdev->bd_dev : 0;
 +              __entry->sector         = bio ? bio->bi_sector : 0;
 +              __entry->nr_sector      = bio ? bio->bi_size >> 9 : 0;
 +              blk_fill_rwbs(__entry->rwbs,
 +                            bio ? bio->bi_rw : 0, __entry->nr_sector);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +        ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_sleeprq,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio, int rw),
 +
 +      TP_ARGS(q, bio, rw),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                     )
 +              __field( sector_t,      sector                  )
 +              __field( unsigned int,  nr_sector               )
 +              __array( char,          rwbs,   6               )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio ? bio->bi_bdev->bd_dev : 0;
 +              __entry->sector         = bio ? bio->bi_sector : 0;
 +              __entry->nr_sector      = bio ? bio->bi_size >> 9 : 0;
 +              blk_fill_rwbs(__entry->rwbs,
 +                          bio ? bio->bi_rw : 0, __entry->nr_sector);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector, __entry->comm)
 +);
 +
 +TRACE_EVENT(block_plug,
 +
 +      TP_PROTO(struct request_queue *q),
 +
 +      TP_ARGS(q),
 +
 +      TP_STRUCT__entry(
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("[%s]", __entry->comm)
 +);
 +
 +TRACE_EVENT(block_unplug_timer,
 +
 +      TP_PROTO(struct request_queue *q),
 +
 +      TP_ARGS(q),
 +
 +      TP_STRUCT__entry(
 +              __field( int,           nr_rq                   )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->nr_rq  = q->rq.count[READ] + q->rq.count[WRITE];
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
 +);
 +
 +TRACE_EVENT(block_unplug_io,
 +
 +      TP_PROTO(struct request_queue *q),
 +
 +      TP_ARGS(q),
 +
 +      TP_STRUCT__entry(
 +              __field( int,           nr_rq                   )
 +              __array( char,          comm,   TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->nr_rq  = q->rq.count[READ] + q->rq.count[WRITE];
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("[%s] %d", __entry->comm, __entry->nr_rq)
 +);
 +
 +TRACE_EVENT(block_split,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio,
 +               unsigned int new_sector),
 +
 +      TP_ARGS(q, bio, new_sector),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev                             )
 +              __field( sector_t,      sector                          )
 +              __field( sector_t,      new_sector                      )
 +              __array( char,          rwbs,           6               )
 +              __array( char,          comm,           TASK_COMM_LEN   )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->new_sector     = new_sector;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +              memcpy(__entry->comm, current->comm, TASK_COMM_LEN);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu / %llu [%s]",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                (unsigned long long)__entry->new_sector,
 +                __entry->comm)
 +);
 +
 +TRACE_EVENT(block_remap,
 +
 +      TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev,
 +               sector_t from),
 +
 +      TP_ARGS(q, bio, dev, from),
 +
 +      TP_STRUCT__entry(
 +              __field( dev_t,         dev             )
 +              __field( sector_t,      sector          )
 +              __field( unsigned int,  nr_sector       )
 +              __field( dev_t,         old_dev         )
 +              __field( sector_t,      old_sector      )
 +              __array( char,          rwbs,   6       )
 +      ),
 +
 +      TP_fast_assign(
 +              __entry->dev            = bio->bi_bdev->bd_dev;
 +              __entry->sector         = bio->bi_sector;
 +              __entry->nr_sector      = bio->bi_size >> 9;
 +              __entry->old_dev        = dev;
 +              __entry->old_sector     = from;
 +              blk_fill_rwbs(__entry->rwbs, bio->bi_rw, bio->bi_size);
 +      ),
 +
 +      TP_printk("%d,%d %s %llu + %u <- (%d,%d) %llu",
 +                MAJOR(__entry->dev), MINOR(__entry->dev), __entry->rwbs,
 +                (unsigned long long)__entry->sector,
 +                __entry->nr_sector,
 +                MAJOR(__entry->old_dev), MINOR(__entry->old_dev),
 +                (unsigned long long)__entry->old_sector)
 +);
 +
 +#endif /* _TRACE_BLOCK_H */
 +
 +/* This part must be outside protection */
 +#include <trace/define_trace.h>
 +

diff --cc kernel/trace/blktrace.c
index 7bd6a98,5708a14..39af8af
--- 1/kernel/trace/blktrace.c
--- 2/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@@ -1657,80 -1548,3 +1657,77 @@@ out
        return ret ? ret : count;
  }
  
-       if (blk_pc_request(rq))
-               bytes = rq->data_len;
-       else
-               bytes = rq->hard_nr_sectors << 9;
 +int blk_trace_init_sysfs(struct device *dev)
 +{
 +      return sysfs_create_group(&dev->kobj, &blk_trace_attr_group);
 +}
 +
 +#endif /* CONFIG_BLK_DEV_IO_TRACE */
 +
 +#ifdef CONFIG_EVENT_TRACING
 +
 +void blk_dump_cmd(char *buf, struct request *rq)
 +{
 +      int i, end;
 +      int len = rq->cmd_len;
 +      unsigned char *cmd = rq->cmd;
 +
 +      if (!blk_pc_request(rq)) {
 +              buf[0] = '\0';
 +              return;
 +      }
 +
 +      for (end = len - 1; end >= 0; end--)
 +              if (cmd[end])
 +                      break;
 +      end++;
 +
 +      for (i = 0; i < len; i++) {
 +              buf += sprintf(buf, "%s%02x", i == 0 ? "" : " ", cmd[i]);
 +              if (i == end && end != len - 1) {
 +                      sprintf(buf, " ..");
 +                      break;
 +              }
 +      }
 +}
 +
 +void blk_fill_rwbs(char *rwbs, u32 rw, int bytes)
 +{
 +      int i = 0;
 +
 +      if (rw & WRITE)
 +              rwbs[i++] = 'W';
 +      else if (rw & 1 << BIO_RW_DISCARD)
 +              rwbs[i++] = 'D';
 +      else if (bytes)
 +              rwbs[i++] = 'R';
 +      else
 +              rwbs[i++] = 'N';
 +
 +      if (rw & 1 << BIO_RW_AHEAD)
 +              rwbs[i++] = 'A';
 +      if (rw & 1 << BIO_RW_BARRIER)
 +              rwbs[i++] = 'B';
 +      if (rw & 1 << BIO_RW_SYNCIO)
 +              rwbs[i++] = 'S';
 +      if (rw & 1 << BIO_RW_META)
 +              rwbs[i++] = 'M';
 +
 +      rwbs[i] = '\0';
 +}
 +
 +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);
 +
++      bytes = blk_rq_bytes(rq);
 +
 +      blk_fill_rwbs(rwbs, rw, bytes);
 +}
 +
 +#endif /* CONFIG_EVENT_TRACING */
 +

diff --cc mm/bounce.c
Simple merge