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

15 files changed, 169 insertions, 220 deletions

diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index be5099dd94b5..c7076ce25e21 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1825,7 +1825,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
         if (linked_comm && SCpnt->device->queue_depth > 2
             && TLDEV(SCpnt->device->type)) {
                 ha->cp_stat[i] = READY;
-                flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
+                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 0);
                 return 0;
         }
 
@@ -2144,13 +2144,13 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                 if (!cpp->din)
                         input_only = 0;
 
-                if (SCpnt->request->sector < minsec)
-                        minsec = SCpnt->request->sector;
-                if (SCpnt->request->sector > maxsec)
-                        maxsec = SCpnt->request->sector;
+                if (blk_rq_pos(SCpnt->request) < minsec)
+                        minsec = blk_rq_pos(SCpnt->request);
+                if (blk_rq_pos(SCpnt->request) > maxsec)
+                        maxsec = blk_rq_pos(SCpnt->request);
 
-                sl[n] = SCpnt->request->sector;
-                ioseek += SCpnt->request->nr_sectors;
+                sl[n] = blk_rq_pos(SCpnt->request);
+                ioseek += blk_rq_sectors(SCpnt->request);
 
                 if (!n)
                         continue;
@@ -2190,7 +2190,7 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         k = il[n];
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
-                        ll[n] = SCpnt->request->nr_sectors;
+                        ll[n] = blk_rq_sectors(SCpnt->request);
                         pl[n] = SCpnt->serial_number;
 
                         if (!n)
@@ -2236,12 +2236,12 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %ld"
+                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %u"
                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
                              SCpnt->serial_number, k, flushcount,
-                             n_ready, SCpnt->request->sector,
-                             SCpnt->request->nr_sectors, cursec, YESNO(s),
+                             n_ready, blk_rq_pos(SCpnt->request),
+                             blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
                              YESNO(r), YESNO(rev), YESNO(input_only),
                              YESNO(overlap), cpp->din);
                 }
@@ -2408,7 +2408,7 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
 
         if (linked_comm && SCpnt->device->queue_depth > 2
             && TLDEV(SCpnt->device->type))
-                flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
+                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 1);
 
         tstatus = status_byte(spp->target_status);
 
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 3da02e436788..54fa1e42dc4d 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -1927,21 +1927,21 @@ int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         /* do we need to support multiple segments? */
         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
                 printk("%s: multiple segments req %u %u, rsp %u %u\n",
-                       __func__, req->bio->bi_vcnt, req->data_len,
-                       rsp->bio->bi_vcnt, rsp->data_len);
+                       __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
+                       rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
                 return -EINVAL;
         }
 
-        ret = smp_execute_task(dev, bio_data(req->bio), req->data_len,
-                               bio_data(rsp->bio), rsp->data_len);
+        ret = smp_execute_task(dev, bio_data(req->bio), blk_rq_bytes(req),
+                               bio_data(rsp->bio), blk_rq_bytes(rsp));
         if (ret > 0) {
                 /* positive number is the untransferred residual */
-                rsp->data_len = ret;
-                req->data_len = 0;
+                rsp->resid_len = ret;
+                req->resid_len = 0;
                 ret = 0;
         } else if (ret == 0) {
-                rsp->data_len = 0;
-                req->data_len = 0;
+                rsp->resid_len = 0;
+                req->resid_len = 0;
         }
 
         return ret;
diff --git a/drivers/scsi/libsas/sas_host_smp.c b/drivers/scsi/libsas/sas_host_smp.c
index d110a366c48a..1bc3b7567994 100644
--- a/drivers/scsi/libsas/sas_host_smp.c
+++ b/drivers/scsi/libsas/sas_host_smp.c
@@ -134,24 +134,24 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 {
         u8 *req_data = NULL, *resp_data = NULL, *buf;
         struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
-        int error = -EINVAL, resp_data_len = rsp->data_len;
+        int error = -EINVAL;
 
         /* eight is the minimum size for request and response frames */
-        if (req->data_len < 8 || rsp->data_len < 8)
+        if (blk_rq_bytes(req) < 8 || blk_rq_bytes(rsp) < 8)
                 goto out;
 
-        if (bio_offset(req->bio) + req->data_len > PAGE_SIZE ||
-            bio_offset(rsp->bio) + rsp->data_len > PAGE_SIZE) {
+        if (bio_offset(req->bio) + blk_rq_bytes(req) > PAGE_SIZE ||
+            bio_offset(rsp->bio) + blk_rq_bytes(rsp) > PAGE_SIZE) {
                 shost_printk(KERN_ERR, shost,
                         "SMP request/response frame crosses page boundary");
                 goto out;
         }
 
-        req_data = kzalloc(req->data_len, GFP_KERNEL);
+        req_data = kzalloc(blk_rq_bytes(req), GFP_KERNEL);
 
         /* make sure frame can always be built ... we copy
          * back only the requested length */
-        resp_data = kzalloc(max(rsp->data_len, 128U), GFP_KERNEL);
+        resp_data = kzalloc(max(blk_rq_bytes(rsp), 128U), GFP_KERNEL);
 
         if (!req_data || !resp_data) {
                 error = -ENOMEM;
@@ -160,7 +160,7 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         local_irq_disable();
         buf = kmap_atomic(bio_page(req->bio), KM_USER0) + bio_offset(req->bio);
-        memcpy(req_data, buf, req->data_len);
+        memcpy(req_data, buf, blk_rq_bytes(req));
         kunmap_atomic(buf - bio_offset(req->bio), KM_USER0);
         local_irq_enable();
 
@@ -178,15 +178,15 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         switch (req_data[1]) {
         case SMP_REPORT_GENERAL:
-                req->data_len -= 8;
-                resp_data_len -= 32;
+                req->resid_len -= 8;
+                rsp->resid_len -= 32;
                 resp_data[2] = SMP_RESP_FUNC_ACC;
                 resp_data[9] = sas_ha->num_phys;
                 break;
 
         case SMP_REPORT_MANUF_INFO:
-                req->data_len -= 8;
-                resp_data_len -= 64;
+                req->resid_len -= 8;
+                rsp->resid_len -= 64;
                 resp_data[2] = SMP_RESP_FUNC_ACC;
                 memcpy(resp_data + 12, shost->hostt->name,
                        SAS_EXPANDER_VENDOR_ID_LEN);
@@ -199,13 +199,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_DISCOVER:
-                req->data_len -= 16;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 16;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 56;
+                rsp->resid_len -= 56;
                 sas_host_smp_discover(sas_ha, resp_data, req_data[9]);
                 break;
 
@@ -215,13 +215,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_REPORT_PHY_SATA:
-                req->data_len -= 16;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 16;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 60;
+                rsp->resid_len -= 60;
                 sas_report_phy_sata(sas_ha, resp_data, req_data[9]);
                 break;
 
@@ -238,13 +238,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_PHY_CONTROL:
-                req->data_len -= 44;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 44;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 8;
+                rsp->resid_len -= 8;
                 sas_phy_control(sas_ha, req_data[9], req_data[10],
                                 req_data[32] >> 4, req_data[33] >> 4,
                                 resp_data);
@@ -261,11 +261,10 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         local_irq_disable();
         buf = kmap_atomic(bio_page(rsp->bio), KM_USER0) + bio_offset(rsp->bio);
-        memcpy(buf, resp_data, rsp->data_len);
+        memcpy(buf, resp_data, blk_rq_bytes(rsp));
         flush_kernel_dcache_page(bio_page(rsp->bio));
         kunmap_atomic(buf - bio_offset(rsp->bio), KM_USER0);
         local_irq_enable();
-        rsp->data_len = resp_data_len;
 
  out:
         kfree(req_data);
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 167b66dd34c7..8032c5adb6a9 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1312,10 +1312,10 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         uint32_t bgstat = bgf->bgstat;
         uint64_t failing_sector = 0;
 
-        printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%lx "
+        printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%x "
                         "bgstat=0x%x bghm=0x%x\n",
                         cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
-                        cmd->request->nr_sectors, bgstat, bghm);
+                        blk_rq_sectors(cmd->request), bgstat, bghm);
 
         spin_lock(&_dump_buf_lock);
         if (!_dump_buf_done) {
@@ -2378,15 +2378,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 if (cmnd->cmnd[0] == READ_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9035 BLKGRD: READ @ sector %llu, "
-                                         "count %lu\n",
-                                         (unsigned long long)scsi_get_lba(cmnd),
-                                        cmnd->request->nr_sectors);
+                                        "count %u\n",
+                                        (unsigned long long)scsi_get_lba(cmnd),
+                                        blk_rq_sectors(cmnd->request));
                 else if (cmnd->cmnd[0] == WRITE_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9036 BLKGRD: WRITE @ sector %llu, "
-                                        "count %lu cmd=%p\n",
+                                        "count %u cmd=%p\n",
                                         (unsigned long long)scsi_get_lba(cmnd),
-                                        cmnd->request->nr_sectors,
+                                        blk_rq_sectors(cmnd->request),
                                         cmnd);
 
                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
@@ -2406,15 +2406,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 if (cmnd->cmnd[0] == READ_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9040 dbg: READ @ sector %llu, "
-                                         "count %lu\n",
+                                         "count %u\n",
                                          (unsigned long long)scsi_get_lba(cmnd),
-                                         cmnd->request->nr_sectors);
+                                         blk_rq_sectors(cmnd->request));
                 else if (cmnd->cmnd[0] == WRITE_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9041 dbg: WRITE @ sector %llu, "
-                                         "count %lu cmd=%p\n",
+                                         "count %u cmd=%p\n",
                                          (unsigned long long)scsi_get_lba(cmnd),
-                                         cmnd->request->nr_sectors, cmnd);
+                                         blk_rq_sectors(cmnd->request), cmnd);
                 else
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9042 dbg: parser not implemented\n");
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index e03dc0b1e1a0..5c65da519e39 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -1041,7 +1041,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
                 printk(MPT2SAS_ERR_FMT "%s: multiple segments req %u %u, "
                     "rsp %u %u\n", ioc->name, __func__, req->bio->bi_vcnt,
-                    req->data_len, rsp->bio->bi_vcnt, rsp->data_len);
+                    blk_rq_bytes(req), rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
                 return -EINVAL;
         }
 
@@ -1104,7 +1104,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         *((u64 *)&mpi_request->SASAddress) = (rphy) ?
             cpu_to_le64(rphy->identify.sas_address) :
             cpu_to_le64(ioc->sas_hba.sas_address);
-        mpi_request->RequestDataLength = cpu_to_le16(req->data_len - 4);
+        mpi_request->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
         psge = &mpi_request->SGL;
 
         /* WRITE sgel first */
@@ -1112,13 +1112,13 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
             MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
         dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
-              req->data_len, PCI_DMA_BIDIRECTIONAL);
+                blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_out) {
                 mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
                 goto unmap;
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (req->data_len - 4),
+        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(req) - 4),
             dma_addr_out);
 
         /* incr sgel */
@@ -1129,14 +1129,14 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
             MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
             MPI2_SGE_FLAGS_END_OF_LIST);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
-        dma_addr_in =  pci_map_single(ioc->pdev, bio_data(rsp->bio),
-              rsp->data_len, PCI_DMA_BIDIRECTIONAL);
+        dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
+                                     blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_in) {
                 mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
                 goto unmap;
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (rsp->data_len + 4),
+        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(rsp) + 4),
             dma_addr_in);
 
         dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s - "
@@ -1170,9 +1170,8 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
 
                 memcpy(req->sense, mpi_reply, sizeof(*mpi_reply));
                 req->sense_len = sizeof(*mpi_reply);
-                req->data_len = 0;
-                rsp->data_len -= mpi_reply->ResponseDataLength;
-
+                req->resid_len = 0;
+                rsp->resid_len -= mpi_reply->ResponseDataLength;
         } else {
                 dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT
                     "%s - no reply\n", ioc->name, __func__));
@@ -1188,10 +1187,10 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
 
  unmap:
         if (dma_addr_out)
-                pci_unmap_single(ioc->pdev, dma_addr_out, req->data_len,
+                pci_unmap_single(ioc->pdev, dma_addr_out, blk_rq_bytes(req),
                     PCI_DMA_BIDIRECTIONAL);
         if (dma_addr_in)
-                pci_unmap_single(ioc->pdev, dma_addr_in, rsp->data_len,
+                pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
                     PCI_DMA_BIDIRECTIONAL);
 
  out:
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 1ce6b24abab2..5776b2ab6b12 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -889,26 +889,6 @@ int osd_req_add_set_attr_list(struct osd_request *or,
 }
 EXPORT_SYMBOL(osd_req_add_set_attr_list);
 
-static int _append_map_kern(struct request *req,
-        void *buff, unsigned len, gfp_t flags)
-{
-        struct bio *bio;
-        int ret;
-
-        bio = bio_map_kern(req->q, buff, len, flags);
-        if (IS_ERR(bio)) {
-                OSD_ERR("Failed bio_map_kern(%p, %d) => %ld\n", buff, len,
-                        PTR_ERR(bio));
-                return PTR_ERR(bio);
-        }
-        ret = blk_rq_append_bio(req->q, req, bio);
-        if (ret) {
-                OSD_ERR("Failed blk_rq_append_bio(%p) => %d\n", bio, ret);
-                bio_put(bio);
-        }
-        return ret;
-}
-
 static int _req_append_segment(struct osd_request *or,
         unsigned padding, struct _osd_req_data_segment *seg,
         struct _osd_req_data_segment *last_seg, struct _osd_io_info *io)
@@ -924,14 +904,14 @@ static int _req_append_segment(struct osd_request *or,
                 else
                         pad_buff = io->pad_buff;
 
-                ret = _append_map_kern(io->req, pad_buff, padding,
+                ret = blk_rq_map_kern(io->req->q, io->req, pad_buff, padding,
                                        or->alloc_flags);
                 if (ret)
                         return ret;
                 io->total_bytes += padding;
         }
 
-        ret = _append_map_kern(io->req, seg->buff, seg->total_bytes,
+        ret = blk_rq_map_kern(io->req->q, io->req, seg->buff, seg->total_bytes,
                                or->alloc_flags);
         if (ret)
                 return ret;
@@ -1293,6 +1273,21 @@ static int _osd_req_finalize_data_integrity(struct osd_request *or,
 /*
  * osd_finalize_request and helpers
  */
+static struct request *_make_request(struct request_queue *q, bool has_write,
+                              struct _osd_io_info *oii, gfp_t flags)
+{
+        if (oii->bio)
+                return blk_make_request(q, oii->bio, flags);
+        else {
+                struct request *req;
+
+                req = blk_get_request(q, has_write ? WRITE : READ, flags);
+                if (unlikely(!req))
+                        return ERR_PTR(-ENOMEM);
+
+                return req;
+        }
+}
 
 static int _init_blk_request(struct osd_request *or,
         bool has_in, bool has_out)
@@ -1301,11 +1296,13 @@ static int _init_blk_request(struct osd_request *or,
         struct scsi_device *scsi_device = or->osd_dev->scsi_device;
         struct request_queue *q = scsi_device->request_queue;
         struct request *req;
-        int ret = -ENOMEM;
+        int ret;
 
-        req = blk_get_request(q, has_out, flags);
-        if (!req)
+        req = _make_request(q, has_out, has_out ? &or->out : &or->in, flags);
+        if (IS_ERR(req)) {
+                ret = PTR_ERR(req);
                 goto out;
+        }
 
         or->request = req;
         req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1318,9 +1315,10 @@ static int _init_blk_request(struct osd_request *or,
                 or->out.req = req;
                 if (has_in) {
                         /* allocate bidi request */
-                        req = blk_get_request(q, READ, flags);
-                        if (!req) {
+                        req = _make_request(q, false, &or->in, flags);
+                        if (IS_ERR(req)) {
                                 OSD_DEBUG("blk_get_request for bidi failed\n");
+                                ret = PTR_ERR(req);
                                 goto out;
                         }
                         req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1364,26 +1362,6 @@ int osd_finalize_request(struct osd_request *or,
                 return ret;
         }
 
-        if (or->out.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->out.req,
-                                        or->out.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio out failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("out bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->out.total_bytes), or->out.req->data_len);
-        }
-        if (or->in.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->in.req, or->in.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio in failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("in bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->in.total_bytes), or->in.req->data_len);
-        }
-
         or->out.pad_buff = sg_out_pad_buffer;
         or->in.pad_buff = sg_in_pad_buffer;
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index bb218c8b6e98..dd3f9d2b99fd 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -240,11 +240,11 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
          * is invalid.  Prevent the garbage from being misinterpreted
          * and prevent security leaks by zeroing out the excess data.
          */
-        if (unlikely(req->data_len > 0 && req->data_len <= bufflen))
-                memset(buffer + (bufflen - req->data_len), 0, req->data_len);
+        if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
+                memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
 
         if (resid)
-                *resid = req->data_len;
+                *resid = req->resid_len;
         ret = req->errors;
  out:
         blk_put_request(req);
@@ -546,14 +546,9 @@ static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error,
          * to queue the remainder of them.
          */
         if (blk_end_request(req, error, bytes)) {
-                int leftover = (req->hard_nr_sectors << 9);
-
-                if (blk_pc_request(req))
-                        leftover = req->data_len;
-
                 /* kill remainder if no retrys */
                 if (error && scsi_noretry_cmd(cmd))
-                        blk_end_request(req, error, leftover);
+                        blk_end_request_all(req, error);
                 else {
                         if (requeue) {
                                 /*
@@ -673,34 +668,6 @@ void scsi_release_buffers(struct scsi_cmnd *cmd)
 EXPORT_SYMBOL(scsi_release_buffers);
 
 /*
- * Bidi commands Must be complete as a whole, both sides at once.
- * If part of the bytes were written and lld returned
- * scsi_in()->resid and/or scsi_out()->resid this information will be left
- * in req->data_len and req->next_rq->data_len. The upper-layer driver can
- * decide what to do with this information.
- */
-static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
-{
-        struct request *req = cmd->request;
-        unsigned int dlen = req->data_len;
-        unsigned int next_dlen = req->next_rq->data_len;
-
-        req->data_len = scsi_out(cmd)->resid;
-        req->next_rq->data_len = scsi_in(cmd)->resid;
-
-        /* The req and req->next_rq have not been completed */
-        BUG_ON(blk_end_bidi_request(req, 0, dlen, next_dlen));
-
-        scsi_release_buffers(cmd);
-
-        /*
-         * This will goose the queue request function at the end, so we don't
-         * need to worry about launching another command.
-         */
-        scsi_next_command(cmd);
-}
-
-/*
  * Function:    scsi_io_completion()
  *
  * Purpose:     Completion processing for block device I/O requests.
@@ -739,7 +706,6 @@ static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
 void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
 {
         int result = cmd->result;
-        int this_count;
         struct request_queue *q = cmd->device->request_queue;
         struct request *req = cmd->request;
         int error = 0;
@@ -773,12 +739,22 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         if (!sense_deferred)
                                 error = -EIO;
                 }
+
+                req->resid_len = scsi_get_resid(cmd);
+
                 if (scsi_bidi_cmnd(cmd)) {
-                        /* will also release_buffers */
-                        scsi_end_bidi_request(cmd);
+                        /*
+                         * Bidi commands Must be complete as a whole,
+                         * both sides at once.
+                         */
+                        req->next_rq->resid_len = scsi_in(cmd)->resid;
+
+                        blk_end_request_all(req, 0);
+
+                        scsi_release_buffers(cmd);
+                        scsi_next_command(cmd);
                         return;
                 }
-                req->data_len = scsi_get_resid(cmd);
         }
 
         BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
@@ -787,9 +763,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          * Next deal with any sectors which we were able to correctly
          * handle.
          */
-        SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, "
+        SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, "
                                       "%d bytes done.\n",
-                                      req->nr_sectors, good_bytes));
+                                      blk_rq_sectors(req), good_bytes));
 
         /*
          * Recovered errors need reporting, but they're always treated
@@ -812,7 +788,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          */
         if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL)
                 return;
-        this_count = blk_rq_bytes(req);
 
         error = -EIO;
 
@@ -922,7 +897,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         if (driver_byte(result) & DRIVER_SENSE)
                                 scsi_print_sense("", cmd);
                 }
-                blk_end_request(req, -EIO, blk_rq_bytes(req));
+                blk_end_request_all(req, -EIO);
                 scsi_next_command(cmd);
                 break;
         case ACTION_REPREP:
@@ -965,10 +940,7 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
         count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
         BUG_ON(count > sdb->table.nents);
         sdb->table.nents = count;
-        if (blk_pc_request(req))
-                sdb->length = req->data_len;
-        else
-                sdb->length = req->nr_sectors << 9;
+        sdb->length = blk_rq_bytes(req);
         return BLKPREP_OK;
 }
 
@@ -1087,22 +1059,21 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
                 if (unlikely(ret))
                         return ret;
         } else {
-                BUG_ON(req->data_len);
-                BUG_ON(req->data);
+                BUG_ON(blk_rq_bytes(req));
 
                 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
                 req->buffer = NULL;
         }
 
         cmd->cmd_len = req->cmd_len;
-        if (!req->data_len)
+        if (!blk_rq_bytes(req))
                 cmd->sc_data_direction = DMA_NONE;
         else if (rq_data_dir(req) == WRITE)
                 cmd->sc_data_direction = DMA_TO_DEVICE;
         else
                 cmd->sc_data_direction = DMA_FROM_DEVICE;
         
-        cmd->transfersize = req->data_len;
+        cmd->transfersize = blk_rq_bytes(req);
         cmd->allowed = req->retries;
         return BLKPREP_OK;
 }
@@ -1212,7 +1183,7 @@ int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
                 break;
         case BLKPREP_DEFER:
                 /*
-                 * If we defer, the elv_next_request() returns NULL, but the
+                 * If we defer, the blk_peek_request() returns NULL, but the
                  * queue must be restarted, so we plug here if no returning
                  * command will automatically do that.
                  */
@@ -1388,7 +1359,7 @@ static void scsi_kill_request(struct request *req, struct request_queue *q)
         struct scsi_target *starget = scsi_target(sdev);
         struct Scsi_Host *shost = sdev->host;
 
-        blkdev_dequeue_request(req);
+        blk_start_request(req);
 
         if (unlikely(cmd == NULL)) {
                 printk(KERN_CRIT "impossible request in %s.\n",
@@ -1480,7 +1451,7 @@ static void scsi_request_fn(struct request_queue *q)
 
         if (!sdev) {
                 printk("scsi: killing requests for dead queue\n");
-                while ((req = elv_next_request(q)) != NULL)
+                while ((req = blk_peek_request(q)) != NULL)
                         scsi_kill_request(req, q);
                 return;
         }
@@ -1501,7 +1472,7 @@ static void scsi_request_fn(struct request_queue *q)
                  * that the request is fully prepared even if we cannot 
                  * accept it.
                  */
-                req = elv_next_request(q);
+                req = blk_peek_request(q);
                 if (!req || !scsi_dev_queue_ready(q, sdev))
                         break;
 
@@ -1517,7 +1488,7 @@ static void scsi_request_fn(struct request_queue *q)
                  * Remove the request from the request list.
                  */
                 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
-                        blkdev_dequeue_request(req);
+                        blk_start_request(req);
                 sdev->device_busy++;
 
                 spin_unlock(q->queue_lock);
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 48ba413f7f6a..10303272ba45 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -387,7 +387,7 @@ static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
          * we use REQ_TYPE_BLOCK_PC so scsi_init_io doesn't set the
          * length for us.
          */
-        cmd->sdb.length = rq->data_len;
+        cmd->sdb.length = blk_rq_bytes(rq);
 
         return 0;
 
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 50988cbf7b2d..d606452297cf 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -163,12 +163,10 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
         int (*handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
 
         while (!blk_queue_plugged(q)) {
-                req = elv_next_request(q);
+                req = blk_fetch_request(q);
                 if (!req)
                         break;
 
-                blkdev_dequeue_request(req);
-
                 spin_unlock_irq(q->queue_lock);
 
                 handler = to_sas_internal(shost->transportt)->f->smp_handler;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 84044233b637..bcf3bd40bbd5 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -384,9 +384,9 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         struct scsi_device *sdp = q->queuedata;
         struct gendisk *disk = rq->rq_disk;
         struct scsi_disk *sdkp;
-        sector_t block = rq->sector;
+        sector_t block = blk_rq_pos(rq);
         sector_t threshold;
-        unsigned int this_count = rq->nr_sectors;
+        unsigned int this_count = blk_rq_sectors(rq);
         int ret, host_dif;
 
         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
@@ -413,10 +413,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                                         this_count));
 
         if (!sdp || !scsi_device_online(sdp) ||
-            block + rq->nr_sectors > get_capacity(disk)) {
+            block + blk_rq_sectors(rq) > get_capacity(disk)) {
                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
-                                                "Finishing %ld sectors\n",
-                                                rq->nr_sectors));
+                                                "Finishing %u sectors\n",
+                                                blk_rq_sectors(rq)));
                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
                                                 "Retry with 0x%p\n", SCpnt));
                 goto out;
@@ -463,7 +463,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
          * for this.
          */
         if (sdp->sector_size == 1024) {
-                if ((block & 1) || (rq->nr_sectors & 1)) {
+                if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -473,7 +473,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 }
         }
         if (sdp->sector_size == 2048) {
-                if ((block & 3) || (rq->nr_sectors & 3)) {
+                if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -483,7 +483,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 }
         }
         if (sdp->sector_size == 4096) {
-                if ((block & 7) || (rq->nr_sectors & 7)) {
+                if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -512,10 +512,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         }
 
         SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
-                                        "%s %d/%ld 512 byte blocks.\n",
+                                        "%s %d/%u 512 byte blocks.\n",
                                         (rq_data_dir(rq) == WRITE) ?
                                         "writing" : "reading", this_count,
-                                        rq->nr_sectors));
+                                        blk_rq_sectors(rq)));
 
         /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
         host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
@@ -971,8 +971,8 @@ static struct block_device_operations sd_fops = {
 
 static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
 {
-        u64 start_lba = scmd->request->sector;
-        u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
+        u64 start_lba = blk_rq_pos(scmd->request);
+        u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
         u64 bad_lba;
         int info_valid;
 
@@ -1510,7 +1510,7 @@ got_data:
                  */
                 sector_size = 512;
         }
-        blk_queue_hardsect_size(sdp->request_queue, sector_size);
+        blk_queue_logical_block_size(sdp->request_queue, sector_size);
 
         {
                 char cap_str_2[10], cap_str_10[10];
diff --git a/drivers/scsi/sd_dif.c b/drivers/scsi/sd_dif.c
index 184dff492797..82f14a9482d0 100644
--- a/drivers/scsi/sd_dif.c
+++ b/drivers/scsi/sd_dif.c
@@ -507,7 +507,7 @@ void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
         sector_sz = scmd->device->sector_size;
         sectors = good_bytes / sector_sz;
 
-        phys = scmd->request->sector & 0xffffffff;
+        phys = blk_rq_pos(scmd->request) & 0xffffffff;
         if (sector_sz == 4096)
                 phys >>= 3;
 
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 91e316fe6522..8201387b4daa 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -289,8 +289,8 @@ sg_open(struct inode *inode, struct file *filp)
         if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
                 sdp->sgdebug = 0;
                 q = sdp->device->request_queue;
-                sdp->sg_tablesize = min(q->max_hw_segments,
-                                        q->max_phys_segments);
+                sdp->sg_tablesize = min(queue_max_hw_segments(q),
+                                        queue_max_phys_segments(q));
         }
         if ((sfp = sg_add_sfp(sdp, dev)))
                 filp->private_data = sfp;
@@ -909,7 +909,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                 if (val < 0)
                         return -EINVAL;
                 val = min_t(int, val,
-                                sdp->device->request_queue->max_sectors * 512);
+                            queue_max_sectors(sdp->device->request_queue) * 512);
                 if (val != sfp->reserve.bufflen) {
                         if (sg_res_in_use(sfp) || sfp->mmap_called)
                                 return -EBUSY;
@@ -919,7 +919,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                 return 0;
         case SG_GET_RESERVED_SIZE:
                 val = min_t(int, sfp->reserve.bufflen,
-                                sdp->device->request_queue->max_sectors * 512);
+                            queue_max_sectors(sdp->device->request_queue) * 512);
                 return put_user(val, ip);
         case SG_SET_COMMAND_Q:
                 result = get_user(val, ip);
@@ -1059,7 +1059,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                         return -ENODEV;
                 return scsi_ioctl(sdp->device, cmd_in, p);
         case BLKSECTGET:
-                return put_user(sdp->device->request_queue->max_sectors * 512,
+                return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
                                 ip);
         case BLKTRACESETUP:
                 return blk_trace_setup(sdp->device->request_queue,
@@ -1261,7 +1261,7 @@ static void sg_rq_end_io(struct request *rq, int uptodate)
 
         sense = rq->sense;
         result = rq->errors;
-        resid = rq->data_len;
+        resid = rq->resid_len;
 
         SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
                 sdp->disk->disk_name, srp->header.pack_id, result));
@@ -1378,7 +1378,8 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         sdp->device = scsidp;
         INIT_LIST_HEAD(&sdp->sfds);
         init_waitqueue_head(&sdp->o_excl_wait);
-        sdp->sg_tablesize = min(q->max_hw_segments, q->max_phys_segments);
+        sdp->sg_tablesize = min(queue_max_hw_segments(q),
+                                queue_max_phys_segments(q));
         sdp->index = k;
         kref_init(&sdp->d_ref);
 
@@ -2056,7 +2057,7 @@ sg_add_sfp(Sg_device * sdp, int dev)
                 sg_big_buff = def_reserved_size;
 
         bufflen = min_t(int, sg_big_buff,
-                        sdp->device->request_queue->max_sectors * 512);
+                        queue_max_sectors(sdp->device->request_queue) * 512);
         sg_build_reserve(sfp, bufflen);
         SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
                            sfp->reserve.bufflen, sfp->reserve.k_use_sg));
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 0e1a0f2d2ad5..cd350dfc1216 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -292,7 +292,8 @@ static int sr_done(struct scsi_cmnd *SCpnt)
                         if (cd->device->sector_size == 2048)
                                 error_sector <<= 2;
                         error_sector &= ~(block_sectors - 1);
-                        good_bytes = (error_sector - SCpnt->request->sector) << 9;
+                        good_bytes = (error_sector -
+                                      blk_rq_pos(SCpnt->request)) << 9;
                         if (good_bytes < 0 || good_bytes >= this_count)
                                 good_bytes = 0;
                         /*
@@ -349,8 +350,8 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
                                 cd->disk->disk_name, block));
 
         if (!cd->device || !scsi_device_online(cd->device)) {
-                SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n",
-                                        rq->nr_sectors));
+                SCSI_LOG_HLQUEUE(2, printk("Finishing %u sectors\n",
+                                           blk_rq_sectors(rq)));
                 SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
                 goto out;
         }
@@ -413,7 +414,7 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
         /*
          * request doesn't start on hw block boundary, add scatter pads
          */
-        if (((unsigned int)rq->sector % (s_size >> 9)) ||
+        if (((unsigned int)blk_rq_pos(rq) % (s_size >> 9)) ||
             (scsi_bufflen(SCpnt) % s_size)) {
                 scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n");
                 goto out;
@@ -422,14 +423,14 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
         this_count = (scsi_bufflen(SCpnt) >> 9) / (s_size >> 9);
 
 
-        SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n",
+        SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%u 512 byte blocks.\n",
                                 cd->cdi.name,
                                 (rq_data_dir(rq) == WRITE) ?
                                         "writing" : "reading",
-                                this_count, rq->nr_sectors));
+                                this_count, blk_rq_sectors(rq)));
 
         SCpnt->cmnd[1] = 0;
-        block = (unsigned int)rq->sector / (s_size >> 9);
+        block = (unsigned int)blk_rq_pos(rq) / (s_size >> 9);
 
         if (this_count > 0xffff) {
                 this_count = 0xffff;
@@ -726,7 +727,7 @@ static void get_sectorsize(struct scsi_cd *cd)
         }
 
         queue = cd->device->request_queue;
-        blk_queue_hardsect_size(queue, sector_size);
+        blk_queue_logical_block_size(queue, sector_size);
 
         return;
 }
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index eb24efea8f14..89bd438e1fe3 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -463,7 +463,7 @@ static void st_scsi_execute_end(struct request *req, int uptodate)
         struct scsi_tape *STp = SRpnt->stp;
 
         STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
-        STp->buffer->cmdstat.residual = req->data_len;
+        STp->buffer->cmdstat.residual = req->resid_len;
 
         if (SRpnt->waiting)
                 complete(SRpnt->waiting);
@@ -3983,8 +3983,8 @@ static int st_probe(struct device *dev)
                 return -ENODEV;
         }
 
-        i = min(SDp->request_queue->max_hw_segments,
-                SDp->request_queue->max_phys_segments);
+        i = min(queue_max_hw_segments(SDp->request_queue),
+                queue_max_phys_segments(SDp->request_queue));
         if (st_max_sg_segs < i)
                 i = st_max_sg_segs;
         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index 601e95141cbe..54023d41fd15 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1306,7 +1306,7 @@ static int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scs
    if (linked_comm && SCpnt->device->queue_depth > 2
                                      && TLDEV(SCpnt->device->type)) {
       HD(j)->cp_stat[i] = READY;
-      flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE);
+      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, FALSE);
       return 0;
       }
 
@@ -1610,11 +1610,13 @@ static int reorder(unsigned int j, unsigned long cursec,
 
       if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
 
-      if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector;
-      if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector;
+      if (blk_rq_pos(SCpnt->request) < minsec)
+         minsec = blk_rq_pos(SCpnt->request);
+      if (blk_rq_pos(SCpnt->request) > maxsec)
+         maxsec = blk_rq_pos(SCpnt->request);
 
-      sl[n] = SCpnt->request->sector;
-      ioseek += SCpnt->request->nr_sectors;
+      sl[n] = blk_rq_pos(SCpnt->request);
+      ioseek += blk_rq_sectors(SCpnt->request);
 
       if (!n) continue;
 
@@ -1642,7 +1644,7 @@ static int reorder(unsigned int j, unsigned long cursec,
 
    if (!input_only) for (n = 0; n < n_ready; n++) {
       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-      ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->serial_number;
+      ll[n] = blk_rq_sectors(SCpnt->request); pl[n] = SCpnt->serial_number;
 
       if (!n) continue;
 
@@ -1666,12 +1668,12 @@ static int reorder(unsigned int j, unsigned long cursec,
    if (link_statistics && (overlap || !(flushcount % link_statistics)))
       for (n = 0; n < n_ready; n++) {
          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\
+         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\
                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
                 SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready,
-                SCpnt->request->sector, SCpnt->request->nr_sectors, cursec,
-                YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
+                blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
+                cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
                 YESNO(overlap), cpp->xdir);
          }
 #endif
@@ -1799,7 +1801,7 @@ static irqreturn_t ihdlr(unsigned int j)
 
    if (linked_comm && SCpnt->device->queue_depth > 2
                                      && TLDEV(SCpnt->device->type))
-      flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE);
+      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, TRUE);
 
    tstatus = status_byte(spp->target_status);