block: convert to pos and nr_sectors accessors

With recent cleanups, there is no place where low level driver
directly manipulates request fields.  This means that the 'hard'
request fields always equal the !hard fields.  Convert all
rq->sectors, nr_sectors and current_nr_sectors references to
accessors.

While at it, drop superflous blk_rq_pos() < 0 test in swim.c.

[ Impact: use pos and nr_sectors accessors ]

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
Tested-by: Grant Likely <grant.likely@secretlab.ca>
Acked-by: Grant Likely <grant.likely@secretlab.ca>
Tested-by: Adrian McMenamin <adrian@mcmen.demon.co.uk>
Acked-by: Adrian McMenamin <adrian@mcmen.demon.co.uk>
Acked-by: Mike Miller <mike.miller@hp.com>
Cc: James Bottomley <James.Bottomley@HansenPartnership.com>
Cc: Bartlomiej Zolnierkiewicz <bzolnier@gmail.com>
Cc: Borislav Petkov <petkovbb@googlemail.com>
Cc: Sergei Shtylyov <sshtylyov@ru.mvista.com>
Cc: Eric Moore <Eric.Moore@lsi.com>
Cc: Alan Stern <stern@rowland.harvard.edu>
Cc: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Cc: Pete Zaitcev <zaitcev@redhat.com>
Cc: Stephen Rothwell <sfr@canb.auug.org.au>
Cc: Paul Clements <paul.clements@steeleye.com>
Cc: Tim Waugh <tim@cyberelk.net>
Cc: Jeff Garzik <jgarzik@pobox.com>
Cc: Jeremy Fitzhardinge <jeremy@xensource.com>
Cc: Alex Dubov <oakad@yahoo.com>
Cc: David Woodhouse <dwmw2@infradead.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Dario Ballabio <ballabio_dario@emc.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Cc: unsik Kim <donari75@gmail.com>
Cc: Laurent Vivier <Laurent@lvivier.info>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

24 files changed, 143 insertions, 139 deletions

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index f22ed6cc69f2..774ab05973a9 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -3338,8 +3338,8 @@ static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_
         }
         Command->Completion = Request->end_io_data;
         Command->LogicalDriveNumber = (long)Request->rq_disk->private_data;
-        Command->BlockNumber = Request->sector;
-        Command->BlockCount = Request->nr_sectors;
+        Command->BlockNumber = blk_rq_pos(Request);
+        Command->BlockCount = blk_rq_sectors(Request);
         Command->Request = Request;
         blkdev_dequeue_request(Request);
         Command->SegmentCount = blk_rq_map_sg(req_q,
@@ -3431,7 +3431,7 @@ static void DAC960_queue_partial_rw(DAC960_Command_T *Command)
    * successfully as possible.
    */
   Command->SegmentCount = 1;
-  Command->BlockNumber = Request->sector;
+  Command->BlockNumber = blk_rq_pos(Request);
   Command->BlockCount = 1;
   DAC960_QueueReadWriteCommand(Command);
   return;
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 8ff95f2c0ede..e4a14b94828e 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1351,13 +1351,13 @@ static void redo_fd_request(void)
         drive = floppy - unit;
 
         /* Here someone could investigate to be more efficient */
-        for (cnt = 0; cnt < CURRENT->current_nr_sectors; cnt++) { 
+        for (cnt = 0; cnt < blk_rq_cur_sectors(CURRENT); cnt++) {
 #ifdef DEBUG
                 printk("fd: sector %ld + %d requested for %s\n",
-                       CURRENT->sector,cnt,
+                       blk_rq_pos(CURRENT), cnt,
                        (rq_data_dir(CURRENT) == READ) ? "read" : "write");
 #endif
-                block = CURRENT->sector + cnt;
+                block = blk_rq_pos(CURRENT) + cnt;
                 if ((int)block > floppy->blocks) {
                         __blk_end_request_cur(CURRENT, -EIO);
                         goto repeat;
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index 25067287211f..234024cda5ec 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -725,7 +725,7 @@ static void do_fd_action( int drive )
             if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
                 if (ReqCmd == READ) {
                     copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
-                    if (++ReqCnt < CURRENT->current_nr_sectors) {
+                    if (++ReqCnt < blk_rq_cur_sectors(CURRENT)) {
                         /* read next sector */
                         setup_req_params( drive );
                         goto repeat;
@@ -1130,7 +1130,7 @@ static void fd_rwsec_done1(int status)
                 }
         }
   
-        if (++ReqCnt < CURRENT->current_nr_sectors) {
+        if (++ReqCnt < blk_rq_cur_sectors(CURRENT)) {
                 /* read next sector */
                 setup_req_params( SelectedDrive );
                 do_fd_action( SelectedDrive );
@@ -1394,7 +1394,7 @@ static void redo_fd_request(void)
 
         DPRINT(("redo_fd_request: CURRENT=%p dev=%s CURRENT->sector=%ld\n",
                 CURRENT, CURRENT ? CURRENT->rq_disk->disk_name : "",
-                CURRENT ? CURRENT->sector : 0 ));
+                CURRENT ? blk_rq_pos(CURRENT) : 0 ));
 
         IsFormatting = 0;
 
@@ -1440,7 +1440,7 @@ repeat:
                 UD.autoprobe = 0;
         }
         
-        if (CURRENT->sector + 1 > UDT->blocks) {
+        if (blk_rq_pos(CURRENT) + 1 > UDT->blocks) {
                 __blk_end_request_cur(CURRENT, -EIO);
                 goto repeat;
         }
@@ -1450,7 +1450,7 @@ repeat:
                 
         ReqCnt = 0;
         ReqCmd = rq_data_dir(CURRENT);
-        ReqBlock = CURRENT->sector;
+        ReqBlock = blk_rq_pos(CURRENT);
         ReqBuffer = CURRENT->buffer;
         setup_req_params( drive );
         do_fd_action( drive );
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index f22d4932433f..ab7b04c0db70 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2835,10 +2835,10 @@ static void do_cciss_request(struct request_queue *q)
         c->Request.Timeout = 0; // Don't time out
         c->Request.CDB[0] =
             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
-        start_blk = creq->sector;
+        start_blk = blk_rq_pos(creq);
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
-               (int)creq->nr_sectors);
+        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",
+               (int)blk_rq_pos(creq), (int)blk_rq_sectors(creq));
 #endif                          /* CCISS_DEBUG */
 
         sg_init_table(tmp_sg, MAXSGENTRIES);
@@ -2864,8 +2864,8 @@ static void do_cciss_request(struct request_queue *q)
                 h->maxSG = seg;
 
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: Submitting %lu sectors in %d segments\n",
-               creq->nr_sectors, seg);
+        printk(KERN_DEBUG "cciss: Submitting %u sectors in %d segments\n",
+               blk_rq_sectors(creq), seg);
 #endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
@@ -2877,8 +2877,8 @@ static void do_cciss_request(struct request_queue *q)
                         c->Request.CDB[4] = (start_blk >> 8) & 0xff;
                         c->Request.CDB[5] = start_blk & 0xff;
                         c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
-                        c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
-                        c->Request.CDB[8] = creq->nr_sectors & 0xff;
+                        c->Request.CDB[7] = (blk_rq_sectors(creq) >> 8) & 0xff;
+                        c->Request.CDB[8] = blk_rq_sectors(creq) & 0xff;
                         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
                 } else {
                         u32 upper32 = upper_32_bits(start_blk);
@@ -2893,10 +2893,10 @@ static void do_cciss_request(struct request_queue *q)
                         c->Request.CDB[7]= (start_blk >> 16) & 0xff;
                         c->Request.CDB[8]= (start_blk >>  8) & 0xff;
                         c->Request.CDB[9]= start_blk & 0xff;
-                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
-                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
-                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
-                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[10]= (blk_rq_sectors(creq) >> 24) & 0xff;
+                        c->Request.CDB[11]= (blk_rq_sectors(creq) >> 16) & 0xff;
+                        c->Request.CDB[12]= (blk_rq_sectors(creq) >>  8) & 0xff;
+                        c->Request.CDB[13]= blk_rq_sectors(creq) & 0xff;
                         c->Request.CDB[14] = c->Request.CDB[15] = 0;
                 }
         } else if (blk_pc_request(creq)) {
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 488a8f4a60aa..a5caeff4718e 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -919,10 +919,11 @@ queue_next:
         c->hdr.size = sizeof(rblk_t) >> 2;
         c->size += sizeof(rblk_t);
 
-        c->req.hdr.blk = creq->sector;
+        c->req.hdr.blk = blk_rq_pos(creq);
         c->rq = creq;
 DBGPX(
-        printk("sector=%d, nr_sectors=%d\n", creq->sector, creq->nr_sectors);
+        printk("sector=%d, nr_sectors=%u\n",
+               blk_rq_pos(creq), blk_rq_sectors(creq));
 );
         sg_init_table(tmp_sg, SG_MAX);
         seg = blk_rq_map_sg(q, creq, tmp_sg);
@@ -940,9 +941,9 @@ DBGPX(
                                                  tmp_sg[i].offset,
                                                  tmp_sg[i].length, dir);
         }
-DBGPX(  printk("Submitting %d sectors in %d segments\n", creq->nr_sectors, seg); );
+DBGPX(  printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
         c->req.hdr.sg_cnt = seg;
-        c->req.hdr.blk_cnt = creq->nr_sectors;
+        c->req.hdr.blk_cnt = blk_rq_sectors(creq);
         c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
         c->type = CMD_RWREQ;
 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 1300df6f1642..452486283386 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2303,7 +2303,7 @@ static void floppy_end_request(struct request *req, int error)
 
         /* current_count_sectors can be zero if transfer failed */
         if (error)
-                nr_sectors = req->current_nr_sectors;
+                nr_sectors = blk_rq_cur_sectors(req);
         if (__blk_end_request(req, error, nr_sectors << 9))
                 return;
 
@@ -2332,7 +2332,7 @@ static void request_done(int uptodate)
         if (uptodate) {
                 /* maintain values for invalidation on geometry
                  * change */
-                block = current_count_sectors + req->sector;
+                block = current_count_sectors + blk_rq_pos(req);
                 INFBOUND(DRS->maxblock, block);
                 if (block > _floppy->sect)
                         DRS->maxtrack = 1;
@@ -2346,10 +2346,10 @@ static void request_done(int uptodate)
                         /* record write error information */
                         DRWE->write_errors++;
                         if (DRWE->write_errors == 1) {
-                                DRWE->first_error_sector = req->sector;
+                                DRWE->first_error_sector = blk_rq_pos(req);
                                 DRWE->first_error_generation = DRS->generation;
                         }
-                        DRWE->last_error_sector = req->sector;
+                        DRWE->last_error_sector = blk_rq_pos(req);
                         DRWE->last_error_generation = DRS->generation;
                 }
                 spin_lock_irqsave(q->queue_lock, flags);
@@ -2503,24 +2503,24 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
 
         max_sector = transfer_size(ssize,
                                    min(max_sector, max_sector_2),
-                                   current_req->nr_sectors);
+                                   blk_rq_sectors(current_req));
 
         if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
-            buffer_max > fsector_t + current_req->nr_sectors)
+            buffer_max > fsector_t + blk_rq_sectors(current_req))
                 current_count_sectors = min_t(int, buffer_max - fsector_t,
-                                              current_req->nr_sectors);
+                                              blk_rq_sectors(current_req));
 
         remaining = current_count_sectors << 9;
 #ifdef FLOPPY_SANITY_CHECK
-        if ((remaining >> 9) > current_req->nr_sectors &&
+        if ((remaining >> 9) > blk_rq_sectors(current_req) &&
             CT(COMMAND) == FD_WRITE) {
                 DPRINT("in copy buffer\n");
                 printk("current_count_sectors=%ld\n", current_count_sectors);
                 printk("remaining=%d\n", remaining >> 9);
-                printk("current_req->nr_sectors=%ld\n",
-                       current_req->nr_sectors);
+                printk("current_req->nr_sectors=%u\n",
+                       blk_rq_sectors(current_req));
                 printk("current_req->current_nr_sectors=%u\n",
-                       current_req->current_nr_sectors);
+                       blk_rq_cur_sectors(current_req));
                 printk("max_sector=%d\n", max_sector);
                 printk("ssize=%d\n", ssize);
         }
@@ -2530,7 +2530,7 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
 
         dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
 
-        size = current_req->current_nr_sectors << 9;
+        size = blk_rq_cur_sectors(current_req) << 9;
 
         rq_for_each_segment(bv, current_req, iter) {
                 if (!remaining)
@@ -2648,10 +2648,10 @@ static int make_raw_rw_request(void)
 
         max_sector = _floppy->sect * _floppy->head;
 
-        TRACK = (int)current_req->sector / max_sector;
-        fsector_t = (int)current_req->sector % max_sector;
+        TRACK = (int)blk_rq_pos(current_req) / max_sector;
+        fsector_t = (int)blk_rq_pos(current_req) % max_sector;
         if (_floppy->track && TRACK >= _floppy->track) {
-                if (current_req->current_nr_sectors & 1) {
+                if (blk_rq_cur_sectors(current_req) & 1) {
                         current_count_sectors = 1;
                         return 1;
                 } else
@@ -2669,7 +2669,7 @@ static int make_raw_rw_request(void)
                 if (fsector_t >= max_sector) {
                         current_count_sectors =
                             min_t(int, _floppy->sect - fsector_t,
-                                  current_req->nr_sectors);
+                                  blk_rq_sectors(current_req));
                         return 1;
                 }
                 SIZECODE = 2;
@@ -2720,7 +2720,7 @@ static int make_raw_rw_request(void)
 
         in_sector_offset = (fsector_t % _floppy->sect) % ssize;
         aligned_sector_t = fsector_t - in_sector_offset;
-        max_size = current_req->nr_sectors;
+        max_size = blk_rq_sectors(current_req);
         if ((raw_cmd->track == buffer_track) &&
             (current_drive == buffer_drive) &&
             (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
@@ -2729,10 +2729,10 @@ static int make_raw_rw_request(void)
                         copy_buffer(1, max_sector, buffer_max);
                         return 1;
                 }
-        } else if (in_sector_offset || current_req->nr_sectors < ssize) {
+        } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
                 if (CT(COMMAND) == FD_WRITE) {
-                        if (fsector_t + current_req->nr_sectors > ssize &&
-                            fsector_t + current_req->nr_sectors < ssize + ssize)
+                        if (fsector_t + blk_rq_sectors(current_req) > ssize &&
+                            fsector_t + blk_rq_sectors(current_req) < ssize + ssize)
                                 max_size = ssize + ssize;
                         else
                                 max_size = ssize;
@@ -2776,7 +2776,7 @@ static int make_raw_rw_request(void)
                     (indirect * 2 > direct * 3 &&
                      *errors < DP->max_errors.read_track && ((!probing
                        || (DP->read_track & (1 << DRS->probed_format)))))) {
-                        max_size = current_req->nr_sectors;
+                        max_size = blk_rq_sectors(current_req);
                 } else {
                         raw_cmd->kernel_data = current_req->buffer;
                         raw_cmd->length = current_count_sectors << 9;
@@ -2801,7 +2801,7 @@ static int make_raw_rw_request(void)
             fsector_t > buffer_max ||
             fsector_t < buffer_min ||
             ((CT(COMMAND) == FD_READ ||
-              (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
+              (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
              max_sector > 2 * max_buffer_sectors + buffer_min &&
              max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
             /* not enough space */
@@ -2879,8 +2879,8 @@ static int make_raw_rw_request(void)
                                 printk("write\n");
                         return 0;
                 }
-        } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
-                   current_count_sectors > current_req->nr_sectors) {
+        } else if (raw_cmd->length > blk_rq_sectors(current_req) << 9 ||
+                   current_count_sectors > blk_rq_sectors(current_req)) {
                 DPRINT("buffer overrun in direct transfer\n");
                 return 0;
         } else if (raw_cmd->length < current_count_sectors << 9) {
@@ -2990,8 +2990,9 @@ static void do_fd_request(struct request_queue * q)
         if (usage_count == 0) {
                 printk("warning: usage count=0, current_req=%p exiting\n",
                        current_req);
-                printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
-                       current_req->cmd_type, current_req->cmd_flags);
+                printk("sect=%ld type=%x flags=%x\n",
+                       (long)blk_rq_pos(current_req), current_req->cmd_type,
+                       current_req->cmd_flags);
                 return;
         }
         if (test_bit(0, &fdc_busy)) {
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index 75b9ca95c4eb..a3b39940ce02 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -228,7 +228,7 @@ static void dump_status(const char *msg, unsigned int stat)
                         printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
                                 inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
                         if (CURRENT)
-                                printk(", sector=%ld", CURRENT->sector);
+                                printk(", sector=%ld", blk_rq_pos(CURRENT));
                 }
                 printk("\n");
         }
@@ -457,9 +457,9 @@ ok_to_read:
         req = CURRENT;
         insw(HD_DATA, req->buffer, 256);
 #ifdef DEBUG
-        printk("%s: read: sector %ld, remaining = %ld, buffer=%p\n",
-                req->rq_disk->disk_name, req->sector + 1, req->nr_sectors - 1,
-                req->buffer+512);
+        printk("%s: read: sector %ld, remaining = %u, buffer=%p\n",
+               req->rq_disk->disk_name, blk_rq_pos(req) + 1,
+               blk_rq_sectors(req) - 1, req->buffer+512);
 #endif
         if (__blk_end_request(req, 0, 512)) {
                 SET_HANDLER(&read_intr);
@@ -485,7 +485,7 @@ static void write_intr(void)
                         continue;
                 if (!OK_STATUS(i))
                         break;
-                if ((req->nr_sectors <= 1) || (i & DRQ_STAT))
+                if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
                         goto ok_to_write;
         } while (--retries > 0);
         dump_status("write_intr", i);
@@ -589,8 +589,8 @@ repeat:
                 return;
         }
         disk = req->rq_disk->private_data;
-        block = req->sector;
-        nsect = req->nr_sectors;
+        block = blk_rq_pos(req);
+        nsect = blk_rq_sectors(req);
         if (block >= get_capacity(req->rq_disk) ||
             ((block+nsect) > get_capacity(req->rq_disk))) {
                 printk("%s: bad access: block=%d, count=%d\n",
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index 71e56cc28cac..826c3492b9fe 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -220,7 +220,8 @@ static void mg_dump_status(const char *msg, unsigned int stat,
                         if (host->breq) {
                                 req = elv_next_request(host->breq);
                                 if (req)
-                                        printk(", sector=%u", (u32)req->sector);
+                                        printk(", sector=%u",
+                                               (unsigned int)blk_rq_pos(req));
                         }
 
                 }
@@ -493,12 +494,12 @@ static void mg_read(struct request *req)
         u32 j;
         struct mg_host *host = req->rq_disk->private_data;
 
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_RD, NULL) !=
-                        MG_ERR_NONE)
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_RD, NULL) != MG_ERR_NONE)
                 mg_bad_rw_intr(host);
 
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-               req->nr_sectors, req->sector, req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
 
         do {
                 u16 *buff = (u16 *)req->buffer;
@@ -522,14 +523,14 @@ static void mg_write(struct request *req)
         u32 j;
         struct mg_host *host = req->rq_disk->private_data;
 
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_WR, NULL) !=
-                        MG_ERR_NONE) {
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_WR, NULL) != MG_ERR_NONE) {
                 mg_bad_rw_intr(host);
                 return;
         }
 
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-               req->nr_sectors, req->sector, req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
 
         do {
                 u16 *buff = (u16 *)req->buffer;
@@ -579,7 +580,7 @@ ok_to_read:
                               (i << 1));
 
         MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                        req->sector, req->nr_sectors - 1, req->buffer);
+               blk_rq_pos(req), blk_rq_sectors(req) - 1, req->buffer);
 
         /* send read confirm */
         outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
@@ -609,7 +610,7 @@ static void mg_write_intr(struct mg_host *host)
                         break;
                 if (!MG_READY_OK(i))
                         break;
-                if ((req->nr_sectors <= 1) || (i & ATA_DRQ))
+                if ((blk_rq_sectors(req) <= 1) || (i & ATA_DRQ))
                         goto ok_to_write;
         } while (0);
         mg_dump_status("mg_write_intr", i, host);
@@ -627,7 +628,7 @@ ok_to_write:
                         buff++;
                 }
                 MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                                req->sector, req->nr_sectors, req->buffer);
+                       blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
                 host->mg_do_intr = mg_write_intr;
                 mod_timer(&host->timer, jiffies + 3 * HZ);
         }
@@ -749,9 +750,9 @@ static void mg_request(struct request_queue *q)
 
                 del_timer(&host->timer);
 
-                sect_num = req->sector;
+                sect_num = blk_rq_pos(req);
                 /* deal whole segments */
-                sect_cnt = req->nr_sectors;
+                sect_cnt = blk_rq_sectors(req);
 
                 /* sanity check */
                 if (sect_num >= get_capacity(req->rq_disk) ||
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index a9ab8be9d92f..977a57377930 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -110,7 +110,7 @@ static void nbd_end_request(struct request *req)
                         req, error ? "failed" : "done");
 
         spin_lock_irqsave(q->queue_lock, flags);
-        __blk_end_request(req, error, req->nr_sectors << 9);
+        __blk_end_request(req, error, blk_rq_sectors(req) << 9);
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
@@ -231,19 +231,19 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
 {
         int result, flags;
         struct nbd_request request;
-        unsigned long size = req->nr_sectors << 9;
+        unsigned long size = blk_rq_sectors(req) << 9;
 
         request.magic = htonl(NBD_REQUEST_MAGIC);
         request.type = htonl(nbd_cmd(req));
-        request.from = cpu_to_be64((u64) req->sector << 9);
+        request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
         request.len = htonl(size);
         memcpy(request.handle, &req, sizeof(req));
 
-        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
+        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%uB)\n",
                         lo->disk->disk_name, req,
                         nbdcmd_to_ascii(nbd_cmd(req)),
-                        (unsigned long long)req->sector << 9,
-                        req->nr_sectors << 9);
+                        (unsigned long long)blk_rq_pos(req) << 9,
+                        blk_rq_sectors(req) << 9);
         result = sock_xmit(lo, 1, &request, sizeof(request),
                         (nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
         if (result <= 0) {
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 9fd57c2aa463..2d5dc0af55e4 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -728,8 +728,8 @@ static void do_pcd_request(struct request_queue * q)
                         if (cd != pcd_current)
                                 pcd_bufblk = -1;
                         pcd_current = cd;
-                        pcd_sector = pcd_req->sector;
-                        pcd_count = pcd_req->current_nr_sectors;
+                        pcd_sector = blk_rq_pos(pcd_req);
+                        pcd_count = blk_rq_cur_sectors(pcd_req);
                         pcd_buf = pcd_req->buffer;
                         pcd_busy = 1;
                         ps_set_intr(do_pcd_read, NULL, 0, nice);
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 0732df4e901a..9ec5d4ac0b64 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -444,11 +444,11 @@ static enum action do_pd_io_start(void)
 
         pd_cmd = rq_data_dir(pd_req);
         if (pd_cmd == READ || pd_cmd == WRITE) {
-                pd_block = pd_req->sector;
-                pd_count = pd_req->current_nr_sectors;
+                pd_block = blk_rq_pos(pd_req);
+                pd_count = blk_rq_cur_sectors(pd_req);
                 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
                         return Fail;
-                pd_run = pd_req->nr_sectors;
+                pd_run = blk_rq_sectors(pd_req);
                 pd_buf = pd_req->buffer;
                 pd_retries = 0;
                 if (pd_cmd == READ)
@@ -479,7 +479,7 @@ static int pd_next_buf(void)
                 return 0;
         spin_lock_irqsave(&pd_lock, saved_flags);
         __blk_end_request_cur(pd_req, 0);
-        pd_count = pd_req->current_nr_sectors;
+        pd_count = blk_rq_cur_sectors(pd_req);
         pd_buf = pd_req->buffer;
         spin_unlock_irqrestore(&pd_lock, saved_flags);
         return 0;
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index 3871e3586d6d..e88c889aa7f2 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -768,9 +768,9 @@ repeat:
                 return;
 
         pf_current = pf_req->rq_disk->private_data;
-        pf_block = pf_req->sector;
-        pf_run = pf_req->nr_sectors;
-        pf_count = pf_req->current_nr_sectors;
+        pf_block = blk_rq_pos(pf_req);
+        pf_run = blk_rq_sectors(pf_req);
+        pf_count = blk_rq_cur_sectors(pf_req);
 
         if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
                 pf_end_request(-EIO);
@@ -810,7 +810,7 @@ static int pf_next_buf(void)
                 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
                 if (!pf_req)
                         return 1;
-                pf_count = pf_req->current_nr_sectors;
+                pf_count = blk_rq_cur_sectors(pf_req);
                 pf_buf = pf_req->buffer;
         }
         return 0;
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index c2388673684e..8d583081b50a 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -134,13 +134,12 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
         rq_for_each_segment(bv, req, iter)
                 n++;
         dev_dbg(&dev->sbd.core,
-                "%s:%u: %s req has %u bvecs for %lu sectors %lu hard sectors\n",
-                __func__, __LINE__, op, n, req->nr_sectors,
-                blk_rq_sectors(req));
+                "%s:%u: %s req has %u bvecs for %u sectors\n",
+                __func__, __LINE__, op, n, blk_rq_sectors(req));
 #endif
 
-        start_sector = req->sector * priv->blocking_factor;
-        sectors = req->nr_sectors * priv->blocking_factor;
+        start_sector = blk_rq_pos(req) * priv->blocking_factor;
+        sectors = blk_rq_sectors(req) * priv->blocking_factor;
         dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                 __func__, __LINE__, op, sectors, start_sector);
 
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index f59887c5ffbd..9f351bfa15ea 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -416,7 +416,7 @@ static int __send_request(struct request *req)
                 desc->slice = 0;
         }
         desc->status = ~0;
-        desc->offset = (req->sector << 9) / port->vdisk_block_size;
+        desc->offset = (blk_rq_pos(req) << 9) / port->vdisk_block_size;
         desc->size = len;
         desc->ncookies = err;
 
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index 97ef4266c4c7..fc6a1c322933 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -531,7 +531,7 @@ static void redo_fd_request(struct request_queue *q)
         while ((req = elv_next_request(q))) {
 
                 fs = req->rq_disk->private_data;
-                if (req->sector < 0 || req->sector >= fs->total_secs) {
+                if (blk_rq_pos(req) >= fs->total_secs) {
                         __blk_end_request_cur(req, -EIO);
                         continue;
                 }
@@ -551,8 +551,8 @@ static void redo_fd_request(struct request_queue *q)
                         __blk_end_request_cur(req, -EIO);
                         break;
                 case READ:
-                        if (floppy_read_sectors(fs, req->sector,
-                                                req->current_nr_sectors,
+                        if (floppy_read_sectors(fs, blk_rq_pos(req),
+                                                blk_rq_cur_sectors(req),
                                                 req->buffer)) {
                                 __blk_end_request_cur(req, -EIO);
                                 continue;
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 424855945b9b..c1b9a4dc11ba 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -312,14 +312,14 @@ static void start_request(struct floppy_state *fs)
         }
         while (fs->state == idle && (req = elv_next_request(swim3_queue))) {
 #if 0
-                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%ld buf=%p\n",
+                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%u buf=%p\n",
                        req->rq_disk->disk_name, req->cmd,
-                       (long)req->sector, req->nr_sectors, req->buffer);
-                printk("           errors=%d current_nr_sectors=%ld\n",
-                       req->errors, req->current_nr_sectors);
+                       (long)blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
+                printk("           errors=%d current_nr_sectors=%u\n",
+                       req->errors, blk_rq_cur_sectors(req));
 #endif
 
-                if (req->sector >= fs->total_secs) {
+                if (blk_rq_pos(req) >= fs->total_secs) {
                         __blk_end_request_cur(req, -EIO);
                         continue;
                 }
@@ -337,13 +337,14 @@ static void start_request(struct floppy_state *fs)
                         }
                 }
 
-                /* Do not remove the cast. req->sector is now a sector_t and
-                 * can be 64 bits, but it will never go past 32 bits for this
-                 * driver anyway, so we can safely cast it down and not have
-                 * to do a 64/32 division
+                /* Do not remove the cast. blk_rq_pos(req) is now a
+                 * sector_t and can be 64 bits, but it will never go
+                 * past 32 bits for this driver anyway, so we can
+                 * safely cast it down and not have to do a 64/32
+                 * division
                  */
-                fs->req_cyl = ((long)req->sector) / fs->secpercyl;
-                x = ((long)req->sector) % fs->secpercyl;
+                fs->req_cyl = ((long)blk_rq_pos(req)) / fs->secpercyl;
+                x = ((long)blk_rq_pos(req)) % fs->secpercyl;
                 fs->head = x / fs->secpertrack;
                 fs->req_sector = x % fs->secpertrack + 1;
                 fd_req = req;
@@ -420,7 +421,7 @@ static inline void setup_transfer(struct floppy_state *fs)
         struct dbdma_cmd *cp = fs->dma_cmd;
         struct dbdma_regs __iomem *dr = fs->dma;
 
-        if (fd_req->current_nr_sectors <= 0) {
+        if (blk_rq_cur_sectors(fd_req) <= 0) {
                 printk(KERN_ERR "swim3: transfer 0 sectors?\n");
                 return;
         }
@@ -428,8 +429,8 @@ static inline void setup_transfer(struct floppy_state *fs)
                 n = 1;
         else {
                 n = fs->secpertrack - fs->req_sector + 1;
-                if (n > fd_req->current_nr_sectors)
-                        n = fd_req->current_nr_sectors;
+                if (n > blk_rq_cur_sectors(fd_req))
+                        n = blk_rq_cur_sectors(fd_req);
         }
         fs->scount = n;
         swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0);
@@ -600,7 +601,8 @@ static void xfer_timeout(unsigned long data)
         out_8(&sw->control_bic, WRITE_SECTORS | DO_ACTION);
         out_8(&sw->select, RELAX);
         printk(KERN_ERR "swim3: timeout %sing sector %ld\n",
-               (rq_data_dir(fd_req)==WRITE? "writ": "read"), (long)fd_req->sector);
+               (rq_data_dir(fd_req)==WRITE? "writ": "read"),
+               (long)blk_rq_pos(fd_req));
         __blk_end_request_cur(fd_req, -EIO);
         fs->state = idle;
         start_request(fs);
@@ -714,7 +716,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                         } else {
                                 printk("swim3: error %sing block %ld (err=%x)\n",
                                        rq_data_dir(fd_req) == WRITE? "writ": "read",
-                                       (long)fd_req->sector, err);
+                                       (long)blk_rq_pos(fd_req), err);
                                 __blk_end_request_cur(fd_req, -EIO);
                                 fs->state = idle;
                         }
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index 60e85bb6f790..087c94c8b2da 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -903,10 +903,10 @@ queue_one_request:
         msg->sg_count   = n_elem;
         msg->sg_type    = SGT_32BIT;
         msg->handle     = cpu_to_le32(TAG_ENCODE(crq->tag));
-        msg->lba        = cpu_to_le32(rq->sector & 0xffffffff);
-        tmp             = (rq->sector >> 16) >> 16;
+        msg->lba        = cpu_to_le32(blk_rq_pos(rq) & 0xffffffff);
+        tmp             = (blk_rq_pos(rq) >> 16) >> 16;
         msg->lba_high   = cpu_to_le16( (u16) tmp );
-        msg->lba_count  = cpu_to_le16(rq->nr_sectors);
+        msg->lba_count  = cpu_to_le16(blk_rq_sectors(rq));
 
         msg_size = sizeof(struct carm_msg_rw) - sizeof(msg->sg);
         for (i = 0; i < n_elem; i++) {
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 8c2cc71327e3..dc3b899ad2b3 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -726,8 +726,8 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
          * The call to blk_queue_hardsect_size() guarantees that request
          * is aligned, but it is given in terms of 512 byte units, always.
          */
-        block = rq->sector >> lun->capacity.bshift;
-        nblks = rq->nr_sectors >> lun->capacity.bshift;
+        block = blk_rq_pos(rq) >> lun->capacity.bshift;
+        nblks = blk_rq_sectors(rq) >> lun->capacity.bshift;
 
         cmd->cdb[0] = (cmd->dir == UB_DIR_READ)? READ_10: WRITE_10;
         /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */
@@ -739,7 +739,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
         cmd->cdb[8] = nblks;
         cmd->cdb_len = 10;
 
-        cmd->len = rq->nr_sectors * 512;
+        cmd->len = blk_rq_sectors(rq) * 512;
 }
 
 static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index e821eed7132f..2086cb12d3ec 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -252,7 +252,7 @@ static int send_request(struct request *req)
         struct viodasd_device *d;
         unsigned long flags;
 
-        start = (u64)req->sector << 9;
+        start = (u64)blk_rq_pos(req) << 9;
 
         if (rq_data_dir(req) == READ) {
                 direction = DMA_FROM_DEVICE;
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 50745e64414e..1980ab456356 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -85,7 +85,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
         vbr->req = req;
         if (blk_fs_request(vbr->req)) {
                 vbr->out_hdr.type = 0;
-                vbr->out_hdr.sector = vbr->req->sector;
+                vbr->out_hdr.sector = blk_rq_pos(vbr->req);
                 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
         } else if (blk_pc_request(vbr->req)) {
                 vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 14be4c1ed1aa..4ef88018bcde 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -306,8 +306,8 @@ static void do_xd_request (struct request_queue * q)
                 return;
 
         while ((req = elv_next_request(q)) != NULL) {
-                unsigned block = req->sector;
-                unsigned count = req->nr_sectors;
+                unsigned block = blk_rq_pos(req);
+                unsigned count = blk_rq_sectors(req);
                 XD_INFO *disk = req->rq_disk->private_data;
                 int res = 0;
                 int retry;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index b4564479f641..91fc56597e9b 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -231,7 +231,7 @@ static int blkif_queue_request(struct request *req)
         info->shadow[id].request = (unsigned long)req;
 
         ring_req->id = id;
-        ring_req->sector_number = (blkif_sector_t)req->sector;
+        ring_req->sector_number = (blkif_sector_t)blk_rq_pos(req);
         ring_req->handle = info->handle;
 
         ring_req->operation = rq_data_dir(req) ?
@@ -310,11 +310,10 @@ static void do_blkif_request(struct request_queue *rq)
                         goto wait;
 
                 pr_debug("do_blk_req %p: cmd %p, sec %lx, "
-                         "(%u/%li) buffer:%p [%s]\n",
-                         req, req->cmd, (unsigned long)req->sector,
-                         req->current_nr_sectors,
-                         req->nr_sectors, req->buffer,
-                         rq_data_dir(req) ? "write" : "read");
+                         "(%u/%u) buffer:%p [%s]\n",
+                         req, req->cmd, (unsigned long)blk_rq_pos(req),
+                         blk_rq_cur_sectors(req), blk_rq_sectors(req),
+                         req->buffer, rq_data_dir(req) ? "write" : "read");
 
 
                 blkdev_dequeue_request(req);
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 5722931d14c5..97c99b43f881 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -646,13 +646,14 @@ static void ace_fsm_dostate(struct ace_device *ace)
                 /* Okay, it's a data request, set it up for transfer */
                 dev_dbg(ace->dev,
                         "request: sec=%llx hcnt=%x, ccnt=%x, dir=%i\n",
-                        (unsigned long long) req->sector, blk_rq_sectors(req),
-                        req->current_nr_sectors, rq_data_dir(req));
+                        (unsigned long long)blk_rq_pos(req),
+                        blk_rq_sectors(req), blk_rq_cur_sectors(req),
+                        rq_data_dir(req));
 
                 ace->req = req;
                 ace->data_ptr = req->buffer;
-                ace->data_count = req->current_nr_sectors * ACE_BUF_PER_SECTOR;
-                ace_out32(ace, ACE_MPULBA, req->sector & 0x0FFFFFFF);
+                ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR;
+                ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF);
 
                 count = blk_rq_sectors(req);
                 if (rq_data_dir(req)) {
@@ -688,7 +689,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         dev_dbg(ace->dev,
                                 "CFBSY set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                 ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                 ace->data_count, ace->in_irq);
                         ace_fsm_yield(ace);     /* need to poll CFBSY bit */
                         break;
@@ -697,7 +698,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         dev_dbg(ace->dev,
                                 "DATABUF not set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                 ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                 ace->data_count, ace->in_irq);
                         ace_fsm_yieldirq(ace);
                         break;
@@ -721,10 +722,10 @@ static void ace_fsm_dostate(struct ace_device *ace)
                                         blk_rq_cur_bytes(ace->req))) {
                         /* dev_dbg(ace->dev, "next block; h=%u c=%u\n",
                          *      blk_rq_sectors(ace->req),
-                         *      ace->req->current_nr_sectors);
+                         *      blk_rq_cur_sectors(ace->req));
                          */
                         ace->data_ptr = ace->req->buffer;
-                        ace->data_count = ace->req->current_nr_sectors * 16;
+                        ace->data_count = blk_rq_cur_sectors(ace->req) * 16;
                         ace_fsm_yieldirq(ace);
                         break;
                 }
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index b66ad58a3c38..d4e6b71f514a 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -71,12 +71,12 @@ static void do_z2_request(struct request_queue *q)
 {
         struct request *req;
         while ((req = elv_next_request(q)) != NULL) {
-                unsigned long start = req->sector << 9;
-                unsigned long len  = req->current_nr_sectors << 9;
+                unsigned long start = blk_rq_pos(req) << 9;
+                unsigned long len  = blk_rq_cur_sectors(req) << 9;
 
                 if (start + len > z2ram_size) {
                         printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
-                                req->sector, req->current_nr_sectors);
+                                blk_rq_pos(req), blk_rq_cur_sectors(req));
                         __blk_end_request_cur(req, -EIO);
                         continue;
                 }