[PATCH] kill blk_queue_empty()

This finally kills of blk_queue_empty().  This is similar to the patch I
recently sent to fix the SCSI logic as well.  A lot of drivers are doing
this in our core, mainly because that is the way they always did it:

start_queue:
	if (blk_queue_empty(q))
		return;

	rq = elv_next_request(q);
	if (!rq)
		return;

Patch simply removes the blk_queue_empty() check, and adds a check for
!rq return from elv_next_request() if the driver didn't already do that.

Additionally, the AS io scheduler can return NULL from
elv_next_request() if it thinks this is best. This way we are also
prepared for that to work well.

Patch was done by Nick Piggin.

diff --git a/arch/m68k/atari/stram.c b/arch/m68k/atari/stram.c
index 7868a499d8e46afb81aef75673c1d186dda552d8..f09dd0321e84300ea120288fe7cbf15c4618261e 100644 (file)
--- a/arch/m68k/atari/stram.c
+++ b/arch/m68k/atari/stram.c
@@ -976,8 +976,9 @@ static int refcnt = 0;
 
 static void do_stram_request(request_queue_t *q)
 {
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+
+       while ((req = elv_next_request(q)) != NULL) {
                void *start = swap_start + (req->sector << 9);
                unsigned long len = req->current_nr_sectors << 9;
                if ((start + len) > swap_end) {

diff --git a/drivers/acorn/block/fd1772.c b/drivers/acorn/block/fd1772.c
index 2a344695c35b61887cf1ca914bc0e99aaaa6b513..6104ea2e254c18369b88e958a4f5916d9c660a0e 100644 (file)
--- a/drivers/acorn/block/fd1772.c
+++ b/drivers/acorn/block/fd1772.c
@@ -598,7 +598,7 @@ static void fd_error(void)
 {
        printk("FDC1772: fd_error\n");
        /*panic("fd1772: fd_error"); *//* DAG tmp */
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
        CURRENT->errors++;
        if (CURRENT->errors >= MAX_ERRORS) {
@@ -1207,11 +1207,11 @@ 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 : "",
-               !blk_queue_empty(QUEUE) ? CURRENT->sector : 0));
+               CURRENT ? CURRENT->sector : 0));
 
 repeat:
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                goto the_end;
 
        floppy = CURRENT->rq_disk->private_data;

diff --git a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c
index 172b48006da3bff198cc3e17a0540d0c5f95cbd0..dbd0da7492fae210253c036a4b7f22260d105261 100644 (file)
--- a/drivers/acorn/block/mfmhd.c
+++ b/drivers/acorn/block/mfmhd.c
@@ -746,7 +746,7 @@ static void request_done(int uptodate)
                /* No - its the end of the line */
                /* end_request's should have happened at the end of sector DMAs */
                /* Turns Drive LEDs off - may slow it down? */
-               if (blk_queue_empty(QUEUE))
+               if (!elv_next_request(QUEUE))
                        issue_command(CMD_CKV, block, 2);
 
                Busy = 0;
@@ -897,9 +897,9 @@ static void mfm_request(void)
                DBG("mfm_request: loop start\n");
                sti();
 
-               DBG("mfm_request: before blk_queue_empty\n");
+               DBG("mfm_request: before !CURRENT\n");
 
-               if (blk_queue_empty(QUEUE)) {
+               if (!CURRENT) {
                        printk("mfm_request: Exiting due to empty queue (pre)\n");
                        do_mfm = NULL;
                        Busy = 0;

diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index ecad76d1065b57641e61fb05352075c55ac63d1f..9362b6cb01eb486a0b5910dad2370d96e41c4c3d 100644 (file)
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -3181,10 +3181,10 @@ static boolean DAC960_ProcessRequest(DAC960_Controller_T *Controller,
      return false;
 
   while (true) {
-      if (blk_queue_empty(RequestQueue))
-          return false;
-
       Request = elv_next_request(RequestQueue);
+      if (!Request)
+             return false;
+
       Command = DAC960_AllocateCommand(Controller);
       if (Command != NULL)
           break;

diff --git a/drivers/block/acsi.c b/drivers/block/acsi.c
index ea581f6547d4c085d971859e808452e7ba06b72b..02651681338b7cdf49ae8b84b37c8021c8354f2b 100644 (file)
--- a/drivers/block/acsi.c
+++ b/drivers/block/acsi.c
@@ -763,7 +763,7 @@ static void unexpected_acsi_interrupt( void )
 static void bad_rw_intr( void )
 
 {
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
 
        if (++CURRENT->errors >= MAX_ERRORS)
@@ -837,7 +837,7 @@ static void acsi_times_out( unsigned long dummy )
 
        do_acsi = NULL;
        printk( KERN_ERR "ACSI timeout\n" );
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
            return;
        if (++CURRENT->errors >= MAX_ERRORS) {
 #ifdef DEBUG
@@ -956,7 +956,7 @@ static void redo_acsi_request( void )
        if (do_acsi)
                return;
 
-       if (blk_queue_empty(QUEUE)) {
+       if (!CURRENT) {
                do_acsi = NULL;
                ENABLE_IRQ();
                stdma_release();

diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index b473e3b08ce18747a80ce1d4e98da38aac6386ec..a1b73f1a12c59e17d1bee627956059f81cf436c3 100644 (file)
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1365,7 +1365,7 @@ static void redo_fd_request(void)
        unsigned long flags;
 
  repeat:
-       if (blk_queue_empty(QUEUE)) {
+       if (!CURRENT) {
                /* Nothing left to do */
                return;
        }

diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index f0f36de7fcda8554ac6dae31189d0bc64e0879eb..23249c0c11619eba25246356b87dc3c8390845ff 100644 (file)
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -627,7 +627,7 @@ static void fd_error( void )
                return;
        }
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
 
        CURRENT->errors++;
@@ -1435,14 +1435,14 @@ static void redo_fd_request(void)
        struct atari_floppy_struct *floppy;
 
        DPRINT(("redo_fd_request: CURRENT=%p dev=%s CURRENT->sector=%ld\n",
-               CURRENT, !blk_queue_empty(QUEUE) ? CURRENT->rq_disk->disk_name : "",
-               !blk_queue_empty(QUEUE) ? CURRENT->sector : 0 ));
+               CURRENT, CURRENT ? CURRENT->rq_disk->disk_name : "",
+               CURRENT ? CURRENT->sector : 0 ));
 
        IsFormatting = 0;
 
 repeat:
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                goto the_end;
 
        floppy = CURRENT->rq_disk->private_data;

diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index d69451c16c20da687d97c89e2d1a273f857cc1a7..8987b67272cd29700a39797e7760148de11a77ff 100644 (file)
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -1876,10 +1876,10 @@ static void do_cciss_request(request_queue_t *q)
                goto startio;
 
 queue:
-       if (blk_queue_empty(q))
+       creq = elv_next_request(q);
+       if (!creq)
                goto startio;
 
-       creq = elv_next_request(q);
        if (creq->nr_phys_segments > MAXSGENTRIES)
                 BUG();
 

diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 91ed5814471f8561e3228fdf1faffd29a191fb82..f4dfe8761982e63d4b930299767340f5bdbe413c 100644 (file)
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -786,10 +786,10 @@ static void do_ida_request(request_queue_t *q)
                goto startio;
 
 queue_next:
-       if (blk_queue_empty(q))
+       creq = elv_next_request(q);
+       if (!creq)
                goto startio;
 
-       creq = elv_next_request(q);
        if (creq->nr_phys_segments > SG_MAX)
                BUG();
 

diff --git a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c
index 5ed2f6882f6d4df84eaf0d1f0d018d9b918cb8d2..e142103085778f68c96e1fdba0f79a119b367756 100644 (file)
--- a/drivers/block/ll_rw_blk.c
+++ b/drivers/block/ll_rw_blk.c
@@ -1698,7 +1698,7 @@ static int __make_request(request_queue_t *q, struct bio *bio)
 again:
        insert_here = NULL;
 
-       if (blk_queue_empty(q)) {
+       if (elv_queue_empty(q)) {
                blk_plug_device(q);
                goto get_rq;
        }

diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index c13ff60956c061e9fa28fcc8f68de135d54872af..ee5f512844196286b483c42da50f490aa772b867 100644 (file)
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -337,9 +337,9 @@ void nbd_clear_que(struct nbd_device *lo)
 
 static void do_nbd_request(request_queue_t * q)
 {
-
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+       
+       while ((req = elv_next_request(q)) != NULL) {
                struct nbd_device *lo;
 
                if (!(req->flags & REQ_CMD))

diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index 4e2335b6fc724e17bf3529824903f7d2ab207f73..1f64202835b716a2695ae064babe89c7c6f52a5a 100644 (file)
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -739,9 +739,10 @@ static void do_pcd_request(request_queue_t * q)
        if (pcd_busy)
                return;
        while (1) {
-               if (blk_queue_empty(q))
-                       return;
                pcd_req = elv_next_request(q);
+               if (!pcd_req)
+                       return;
+
                if (rq_data_dir(pcd_req) == READ) {
                        struct pcd_unit *cd = pcd_req->rq_disk->private_data;
                        if (cd != pcd_current)

diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 144c42fbca50f000df28a1a57adf0131ba2ccced..a347c67c1eaedf673bbe8bec4a3bc42f85793245 100644 (file)
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -726,10 +726,10 @@ static void do_pd_request(request_queue_t * q)
        if (pd_busy)
                return;
 repeat:
-       if (blk_queue_empty(q))
+       pd_req = elv_next_request(q);
+       if (!pd_req)
                return;
 
-       pd_req = elv_next_request(q);
        pd_block = pd_req->sector;
        pd_run = pd_req->nr_sectors;
        pd_count = pd_req->current_nr_sectors;

diff --git a/drivers/block/ps2esdi.c b/drivers/block/ps2esdi.c
index b71b02fabdf1dfdef7298df3dae259ef4ef8bef0..1d46f052d109f0840d784e46862a40af0e48f9b6 100644 (file)
--- a/drivers/block/ps2esdi.c
+++ b/drivers/block/ps2esdi.c
@@ -477,12 +477,9 @@ static void do_ps2esdi_request(request_queue_t * q)
        /* since, this routine is called with interrupts cleared - they 
           must be before it finishes  */
 
-       /* standard procedure to ensure that requests are really on the
-          list + sanity checks.                     */
-       if (blk_queue_empty(q))
-               return;
-
        req = elv_next_request(q);
+       if (!req)
+               return;
 
 #if 0
        printk("%s:got request. device : %s command : %d  sector : %ld count : %ld, buffer: %p\n",

diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 0b652196606f67d159d85e0d7c3658708fcfe7f8..0348b5330f8df09537712e82370a2446a268eeba 100644 (file)
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -305,6 +305,7 @@ static void do_fd_request(request_queue_t * q)
 
 static void start_request(struct floppy_state *fs)
 {
+       struct request *req;
        unsigned long x;
 
        if (fs->state == idle && fs->wanted) {
@@ -312,8 +313,7 @@ static void start_request(struct floppy_state *fs)
                wake_up(&fs->wait);
                return;
        }
-       while (!blk_queue_empty(&swim3_queue) && fs->state == idle) {
-               struct request *req = elv_next_request(&swim3_queue);
+       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",
                       req->rq_disk->disk_name, req->cmd,

diff --git a/drivers/block/swim_iop.c b/drivers/block/swim_iop.c
index e96d4362b24cc108e038d9c81770662d3d62cbe3..958a333bb29f1f393f6fabe4f1585628e2eab36d 100644 (file)
--- a/drivers/block/swim_iop.c
+++ b/drivers/block/swim_iop.c
@@ -516,7 +516,7 @@ static void start_request(struct floppy_state *fs)
                wake_up(&fs->wait);
                return;
        }
-       while (!blk_queue_empty(&swim_queue) && fs->state == idle) {
+       while (CURRENT && fs->state == idle) {
                if (CURRENT->bh && !buffer_locked(CURRENT->bh))
                        panic("floppy: block not locked");
 #if 0

diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 1da1122dc898fa40b5657412ac7865f528089a9b..206e3247c81e1af94c3547a48fc5ffb434f279db 100644 (file)
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -282,11 +282,12 @@ static u_char __init xd_detect (u_char *controller, unsigned int *address)
 /* do_xd_request: handle an incoming request */
 static void do_xd_request (request_queue_t * q)
 {
+       struct request *req;
+
        if (xdc_busy)
                return;
 
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       while ((req = elv_next_request(q)) != NULL) {
                unsigned block = req->sector;
                unsigned count = req->nr_sectors;
                int rw = rq_data_dir(req);

diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index cac3ee05bfb099e576efe0635d941598e1f814c8..a9b95fb8eef3d38b584e4b4e7fe9ec223a8cdee1 100644 (file)
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -73,8 +73,8 @@ static struct gendisk *z2ram_gendisk;
 
 static void do_z2_request(request_queue_t *q)
 {
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+       while ((req = elv_next_request) != NULL) {
                unsigned long start = req->sector << 9;
                unsigned long len  = req->current_nr_sectors << 9;
 

diff --git a/drivers/cdrom/aztcd.c b/drivers/cdrom/aztcd.c
index 0171a9ea0b405a22f6d134d9602c7843da0bede3..287904f314ca65a6d0467c8b4584920685cd30be 100644 (file)
--- a/drivers/cdrom/aztcd.c
+++ b/drivers/cdrom/aztcd.c
@@ -231,7 +231,7 @@ static struct request_queue azt_queue;
 
 static int current_valid(void)
 {
-        return !blk_queue_empty(QUEUE) &&
+        return CURRENT &&
                CURRENT->cmd == READ &&
                CURRENT->sector != -1;
 }

diff --git a/drivers/cdrom/cdu31a.c b/drivers/cdrom/cdu31a.c
index 915afe6dfe7121786fc3cee62e918c35511b909d..a6b49cacd3f3eea4f7647a6b4cda53484bd9f516 100644 (file)
--- a/drivers/cdrom/cdu31a.c
+++ b/drivers/cdrom/cdu31a.c
@@ -1583,13 +1583,13 @@ static void do_cdu31a_request(request_queue_t * q)
                 * The beginning here is stolen from the hard disk driver.  I hope
                 * it's right.
                 */
-               if (blk_queue_empty(q))
+               req = elv_next_request(q);
+               if (!req)
                        goto end_do_cdu31a_request;
 
                if (!sony_spun_up)
                        scd_spinup();
 
-               req = elv_next_request(q);
                block = req->sector;
                nblock = req->nr_sectors;
 

diff --git a/drivers/cdrom/cm206.c b/drivers/cdrom/cm206.c
index 3fb0301e028de1907b6e2b43a3d65ca087185fff..a91a5f1baf08d47b90bd121b0f7567ba62b4edd7 100644 (file)
--- a/drivers/cdrom/cm206.c
+++ b/drivers/cdrom/cm206.c
@@ -855,10 +855,10 @@ static void do_cm206_request(request_queue_t * q)
        struct request *req;
 
        while (1) {     /* repeat until all requests have been satisfied */
-               if (blk_queue_empty(q))
+               req = elv_next_request(q);
+               if (!req)
                        return;
 
-               req = elv_next_request(q);
                if (req->cmd != READ) {
                        debug(("Non-read command %d on cdrom\n", req->cmd));
                        end_request(req, 0);

diff --git a/drivers/cdrom/gscd.c b/drivers/cdrom/gscd.c
index 209e5c2eb5165b3eb9662289743aa84533240aee..feb97de4e8ded246037b51f0a6f9e4b77a25f0eb 100644 (file)
--- a/drivers/cdrom/gscd.c
+++ b/drivers/cdrom/gscd.c
@@ -257,10 +257,10 @@ static void __do_gscd_request(unsigned long dummy)
        unsigned int nsect;
 
 repeat:
-       if (blk_queue_empty(&gscd_queue))
+       req = elv_next_request(&gscd_queue);
+       if (!req)
                return;
 
-       req = elv_next_request(&gscd_queue);
        block = req->sector;
        nsect = req->nr_sectors;
 

diff --git a/drivers/cdrom/mcd.c b/drivers/cdrom/mcd.c
index 48cbb70d3ccf006b5b80b09f9f81670f800396a6..9fc28c028df72d2cfc4ecea554e4292096a3a99e 100644 (file)
--- a/drivers/cdrom/mcd.c
+++ b/drivers/cdrom/mcd.c
@@ -125,7 +125,7 @@ static struct request_queue mcd_queue;
 
 static int current_valid(void)
 {
-        return !blk_queue_empty(QUEUE) &&
+        return CURRENT &&
                CURRENT->cmd == READ &&
                CURRENT->sector != -1;
 }

diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index 8abd7a0de3119fccb723c9109208fc4f5fcca705..9e125e05a146cbb31fed562ee5fdd14509674abc 100644 (file)
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -582,10 +582,10 @@ void do_mcdx_request(request_queue_t * q)
 
       again:
 
-       if (blk_queue_empty(q))
+       req = elv_next_request(q);
+       if (!req)
                return;
 
-       req = elv_next_request(q);
        stuffp = req->rq_disk->private_data;
 
        if (!stuffp->present) {

diff --git a/drivers/cdrom/optcd.c b/drivers/cdrom/optcd.c
index 874677d8fc8189445c87c4e7a29b393b9a768355..ff13737af509a8995f22cf1b2dae72e31cd7e254 100644 (file)
--- a/drivers/cdrom/optcd.c
+++ b/drivers/cdrom/optcd.c
@@ -977,7 +977,7 @@ static int update_toc(void)
 
 static int current_valid(void)
 {
-        return !blk_queue_empty(QUEUE) &&
+        return CURRENT &&
                CURRENT->cmd == READ &&
                CURRENT->sector != -1;
 }

diff --git a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c
index ae6787aba3db9789653a81b0d1261e047255b9ed..6ecf532d670e4720c48862cfcdc7b444ce4f2395 100644 (file)
--- a/drivers/cdrom/sbpcd.c
+++ b/drivers/cdrom/sbpcd.c
@@ -4852,7 +4852,9 @@ static void do_sbpcd_request(request_queue_t * q)
 #ifdef DEBUG_GTL
        xnr=++xx_nr;
 
-       if(blk_queue_empty(q))
+       req = elv_next_request(q);
+
+       if (!req)
        {
                printk( "do_sbpcd_request[%di](NULL), Pid:%d, Time:%li\n",
                        xnr, current->pid, jiffies);
@@ -4861,15 +4863,14 @@ static void do_sbpcd_request(request_queue_t * q)
                return;
        }
 
-       req = elv_next_request(q);
-
        printk(" do_sbpcd_request[%di](%p:%ld+%ld), Pid:%d, Time:%li\n",
                xnr, req, req->sector, req->nr_sectors, current->pid, jiffies);
 #endif
-       if (blk_queue_empty(q))
+
+       req = elv_next_request(q);      /* take out our request so no other */
+       if (!req)
                return;
 
-       req = elv_next_request(q);              /* take out our request so no other */
        if (req -> sector == -1)
                end_request(req, 0);
        spin_unlock_irq(q->queue_lock);

diff --git a/drivers/cdrom/sjcd.c b/drivers/cdrom/sjcd.c
index 63e909879b9fe08fb38b10b41e322d8956160567..db131a10879561aed545bcaac8fa63a5d0e735ff 100644 (file)
--- a/drivers/cdrom/sjcd.c
+++ b/drivers/cdrom/sjcd.c
@@ -1064,7 +1064,7 @@ static void sjcd_invalidate_buffers(void)
 
 static int current_valid(void)
 {
-        return !blk_queue_empty(QUEUE) &&
+        return CURRENT &&
                CURRENT->cmd == READ &&
                CURRENT->sector != -1;
 }

diff --git a/drivers/cdrom/sonycd535.c b/drivers/cdrom/sonycd535.c
index 4a5730de8af69982833048dc1299eadbdf8fbdb5..4cb25c3c4d68da9f18dbe8822771950d77af406d 100644 (file)
--- a/drivers/cdrom/sonycd535.c
+++ b/drivers/cdrom/sonycd535.c
@@ -797,10 +797,10 @@ do_cdu535_request(request_queue_t * q)
        Byte cmd[2];
 
        while (1) {
-               if (blk_queue_empty(q))
+               req = elv_next_request(q);
+               if (!req)
                        return;
 
-               req = elv_next_request(q);
                block = req->sector;
                nsect = req->nr_sectors;
                if (!(req->flags & REQ_CMD))

diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index ea84e881e2ba1922facb7bf02f681b8cade5ed07..d046370850700dce2523b900af0b99e96e2abc1a 100644 (file)
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -673,7 +673,8 @@ repeat:
        best = NULL;
        drive = hwgroup->drive;
        do {
-               if (!blk_queue_empty(&drive->queue) && (!drive->sleep || time_after_eq(jiffies, drive->sleep))) {
+               if ((!drive->sleep || time_after_eq(jiffies, drive->sleep))
+                   && !elv_queue_empty(&drive->queue)) {
                        if (!best
                         || (drive->sleep && (!best->sleep || 0 < (signed long)(best->sleep - drive->sleep)))
                         || (!best->sleep && 0 < (signed long)(WAKEUP(best) - WAKEUP(drive))))

diff --git a/drivers/ide/legacy/hd.c b/drivers/ide/legacy/hd.c
index d4e6dbbb929b200fed1167a85188151a365fc27c..8946722f911573634f7817dc616d9d2499b53ae1 100644 (file)
--- a/drivers/ide/legacy/hd.c
+++ b/drivers/ide/legacy/hd.c
@@ -194,7 +194,7 @@ void __init hd_setup(char *str, int *ints)
 static void dump_status (const char *msg, unsigned int stat)
 {
        char *name = "hd?";
-       if (!blk_queue_empty(QUEUE))
+       if (CURRENT)
                name = CURRENT->rq_disk->disk_name;
 
 #ifdef VERBOSE_ERRORS
@@ -223,7 +223,7 @@ static void dump_status (const char *msg, unsigned int stat)
                if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
                        printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
                                inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
-                       if (!blk_queue_empty(QUEUE))
+                       if (CURRENT)
                                printk(", sector=%ld", CURRENT->sector);
                }
                printk("\n");
@@ -403,8 +403,8 @@ void unexpected_hd_interrupt(void)
  */
 static void bad_rw_intr(void)
 {
-       if (!blk_queue_empty(QUEUE)) {
-               struct request *req = CURRENT;
+       struct request *req = CURRENT;
+       if (req != NULL) {
                struct hd_i_struct *disk = req->rq_disk->private_data;
                if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
                        end_request(req, 0);
@@ -469,7 +469,7 @@ ok_to_read:
 #if (HD_DELAY > 0)
        last_req = read_timer();
 #endif
-       if (!blk_queue_empty(QUEUE))
+       if (elv_next_request(QUEUE))
                hd_request();
        return;
 }
@@ -532,7 +532,7 @@ static void hd_times_out(unsigned long dummy)
 
        do_hd = NULL;
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
 
        disable_irq(HD_IRQ);
@@ -588,11 +588,11 @@ repeat:
        del_timer(&device_timer);
        local_irq_enable();
 
-       if (blk_queue_empty(QUEUE)) {
+       req = CURRENT;
+       if (!req) {
                do_hd = NULL;
                return;
        }
-       req = CURRENT;
 
        if (reset) {
                local_irq_disable();

diff --git a/drivers/ide/legacy/hd98.c b/drivers/ide/legacy/hd98.c
index a5128619f97241dcbdb614f99d726265ead34c18..c7b61ac8424b999d02ba3be3f7d6da9dc7b1d60a 100644 (file)
--- a/drivers/ide/legacy/hd98.c
+++ b/drivers/ide/legacy/hd98.c
@@ -197,7 +197,7 @@ static void dump_status (const char *msg, unsigned int stat)
 {
        char devc;
 
-       devc = !blk_queue_empty(QUEUE) ? 'a' + DEVICE_NR(CURRENT->rq_dev) : '?';
+       devc = CURRENT ? 'a' + DEVICE_NR(CURRENT->rq_dev) : '?';
 #ifdef VERBOSE_ERRORS
        printk("hd%c: %s: status=0x%02x { ", devc, msg, stat & 0xff);
        if (stat & BUSY_STAT)   printk("Busy ");
@@ -224,7 +224,7 @@ static void dump_status (const char *msg, unsigned int stat)
                if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
                        printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
                                inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
-                       if (!blk_queue_empty(QUEUE))
+                       if (CURRENT)
                                printk(", sector=%ld", CURRENT->sector);
                }
                printk("\n");
@@ -400,7 +400,7 @@ static void bad_rw_intr(void)
 {
        int dev;
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
        dev = DEVICE_NR(CURRENT->rq_dev);
        if (++CURRENT->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
@@ -463,7 +463,7 @@ ok_to_read:
 #if (HD_DELAY > 0)
        last_req = read_timer();
 #endif
-       if (!blk_queue_empty(QUEUE))
+       if (CURRENT)
                hd_request();
        return;
 }
@@ -525,7 +525,7 @@ static void hd_times_out(unsigned long dummy)
 
        do_hd = NULL;
 
-       if (blk_queue_empty(QUEUE))
+       if (!CURRENT)
                return;
 
        disable_irq(HD_IRQ);
@@ -579,7 +579,7 @@ repeat:
        del_timer(&device_timer);
        local_irq_enable();
 
-       if (blk_queue_empty(QUEUE)) {
+       if (!CURRENT) {
                do_hd = NULL;
                return;
        }

diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index 9fb7a5dd8b5eced86822f0a1db38321f30063205..6e812217afa8a40f6a7c108b51e2b69a2b02ddab 100644 (file)
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -783,14 +783,12 @@ static void i2ob_request(request_queue_t *q)
        struct i2ob_device *dev;
        u32 m;
        
-       while (blk_queue_empty(q)) {
+       while ((req = elv_next_request(q)) != NULL) {
                /*
                 *      On an IRQ completion if there is an inactive
                 *      request on the queue head it means it isnt yet
                 *      ready to dispatch.
                 */
-               req = elv_next_request(q);
-
                if(req->rq_status == RQ_INACTIVE)
                        return;
 

diff --git a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c
index fa7ab618f07fb37117a2ac0eefd73770d4eae7a1..fa49bd7d4511ba9ea9f140cacb1cbc0c19153d73 100644 (file)
--- a/drivers/mtd/ftl.c
+++ b/drivers/mtd/ftl.c
@@ -1135,9 +1135,9 @@ static void do_ftl_request(struct request_queue *q)
 
        do {
                //          sti();
-               if (blk_queue_empty(q))
-                       return;
                req = elv_next_request(q);
+               if (!req)
+                       return;
                part = req->rq_disk->private_data;
                if (part) {
                        ret = 0;

diff --git a/drivers/mtd/mtdblock.c b/drivers/mtd/mtdblock.c
index 9883a8ea890fa5707bae7266cd8813eeab15ef66..34bcc7a56e4ade6b7833abbf9ecaf8d6f55146fb 100644 (file)
--- a/drivers/mtd/mtdblock.c
+++ b/drivers/mtd/mtdblock.c
@@ -384,11 +384,11 @@ static release_t mtdblock_release(struct inode *inode, struct file *file)
 static struct request_queue mtd_queue;
 static void handle_mtdblock_request(void)
 {
+       struct request *req;
        struct mtdblk_dev *mtdblk;
        unsigned int res;
 
-       while (!blk_queue_empty(&mtd_queue)) {
-               struct request *req = elv_next_request(&mtd_queue);
+       while ((req = elv_next_request(&mtd_queue) != NULL) {
                struct mtdblk_dev **p = req->rq_disk->private_data;
                spin_unlock_irq(mtd_queue.queue_lock);
                mtdblk = *p;
@@ -458,7 +458,7 @@ int mtdblock_thread(void *dummy)
                add_wait_queue(&thr_wq, &wait);
                set_current_state(TASK_INTERRUPTIBLE);
                spin_lock_irq(mtd_queue.queue_lock);
-               if (blk_queue_empty(&mtd_queue) || blk_queue_plugged(&mtd_queue)) {
+               if (!elv_next_request(&mtd_queue) || blk_queue_plugged(&mtd_queue)) {
                        spin_unlock_irq(mtd_queue.queue_lock);
                        schedule();
                        remove_wait_queue(&thr_wq, &wait); 

diff --git a/drivers/mtd/mtdblock_ro.c b/drivers/mtd/mtdblock_ro.c
index 950d2f5650da0b36da39d69eef0dfe6e7114ceb3..3083f0c41a06f39b66e7abedd57b84b271d6cbbf 100644 (file)
--- a/drivers/mtd/mtdblock_ro.c
+++ b/drivers/mtd/mtdblock_ro.c
@@ -93,8 +93,9 @@ static release_t mtdblock_release(struct inode *inode, struct file *file)
 
 static void mtdblock_request(request_queue_t *q)
 {
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+       
+       while ((req = elv_next_request(q)) != NULL) {
                struct mtdro_dev *mdev = req->rq_disk->private_data;
                struct mtd_info *mtd = mdev->mtd;
                unsigned int res;

diff --git a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c
index 1b99e2a0c07048b7283b1132ac05bf74fda5abe0..7e9414f6263e7c780b96e5532d810f9a92c4030d 100644 (file)
--- a/drivers/mtd/nftlcore.c
+++ b/drivers/mtd/nftlcore.c
@@ -780,8 +780,9 @@ static int nftl_ioctl(struct inode * inode, struct file * file, unsigned int cmd
 
 void nftl_request(struct request_queue *q)
 {
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+       
+       while ((req = elv_next_request(q)) != NULL) {
                unsigned block = req->sector;
                unsigned nsect = req->current_nr_sectors;
                char *buffer = req->buffer;

diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 4a341097e10fc38b91a806ef325a5a253d80f937..204383e5b37abf838e602c4834846c920d5b9bfd 100644 (file)
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -1217,7 +1217,7 @@ __dasd_process_blk_queue(dasd_device_t * device)
                        nr_queued++;
        }
        while (!blk_queue_plugged(queue) &&
-              !blk_queue_empty(queue) &&
+              elv_next_request(queue) &&
                nr_queued < DASD_CHANQ_MAX_SIZE) {
                req = elv_next_request(queue);
                if (device->ro_flag && rq_data_dir(req) == WRITE) {

diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index 6731a38d82be6cb9885c78e73d172ff75a7877ea..8bdb1a9f891feb4f4ff83feef3570c9a94a27e43 100644 (file)
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -69,7 +69,7 @@ __tapeblock_end_request(struct tape_request *ccw_req, void *data)
                device->blk_data.block_position = -1;
        device->discipline->free_bread(ccw_req);
        if (!list_empty(&device->req_queue) ||
-           !blk_queue_empty(&device->blk_data.request_queue))
+           elv_next_request(&device->blk_data.request_queue))
                tasklet_schedule(&device->blk_data.tasklet);
 }
 
@@ -95,7 +95,7 @@ __tape_process_blk_queue(struct tape_device *device, struct list_head *new_req)
        list_for_each(l, &device->req_queue)
                nr_queued++;
        while (!blk_queue_plugged(queue) &&
-              !blk_queue_empty(queue) &&
+              elv_next_request(queue) &&
               nr_queued < TAPEBLOCK_MIN_REQUEUE) {
                req = elv_next_request(queue);
                if (rq_data_dir(req) == WRITE) {
@@ -162,7 +162,7 @@ tapeblock_request_fn(request_queue_t *queue)
        struct tape_device *device;
 
        device = (struct tape_device *) queue->queuedata;
-       while (!blk_queue_empty(queue)) {
+       while (elv_next_request(queue)) {
                INIT_LIST_HEAD(&new_req);
                spin_lock(get_ccwdev_lock(device->cdev));
                __tape_process_blk_queue(device, &new_req);
@@ -187,7 +187,7 @@ tapeblock_tasklet(unsigned long data)
        struct tape_device *device;
 
        device = (struct tape_device *) data;
-       while (!blk_queue_empty(&device->blk_data.request_queue)) {
+       while (elv_next_request(&device->blk_data.request_queue)) {
                INIT_LIST_HEAD(&new_req);
                spin_lock_irq(get_ccwdev_lock(device->cdev));
                __tape_process_blk_queue(device, &new_req);

diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index 81cdfbfa47b114a4becc12884574e6ba625ca76d..7d477c0d01a14c38d1c51ee0bb4c7a501d38226c 100644 (file)
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -190,8 +190,9 @@ static void jsfd_read(char *buf, unsigned long p, size_t togo) {
 
 static void jsfd_do_request(request_queue_t *q)
 {
-       while (!blk_queue_empty(q)) {
-               struct request *req = elv_next_request(q);
+       struct request *req;
+       
+       while ((req = elv_next_request(q)) != NULL) {
                struct jsfd_part *jdp = req->rq_disk->private_data;
                unsigned long offset = req->sector << 9;
                size_t len = req->current_nr_sectors << 9;

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index a6694681aa6d4af9b188e9d23d1e0769852641da..986c27c43268fc24bd05f6c9f6600b72f6f1f8b6 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -398,14 +398,14 @@ static void scsi_queue_next_request(request_queue_t *q, struct scsi_cmnd *cmd)
         * with special case code, then spin off separate versions and
         * use function pointers to pick the right one.
         */
-       if (sdev->single_lun && blk_queue_empty(q) && sdev->device_busy ==0 &&
-                       !shost->host_blocked && !shost->host_self_blocked &&
-                       !((shost->can_queue > 0) && (shost->host_busy >=
-                                                    shost->can_queue))) {
+       if (sdev->single_lun && sdev->device_busy == 0 &&
+           !shost->host_blocked && !shost->host_self_blocked &&
+           !((shost->can_queue > 0) && (shost->host_busy >= shost->can_queue))
+           && elv_queue_empty(q)) {
                list_for_each_entry(sdev2, &sdev->same_target_siblings,
                               same_target_siblings) {
                        if (!sdev2->device_blocked &&
-                           !blk_queue_empty(sdev2->request_queue)) {
+                           !elv_queue_empty(sdev2->request_queue)) {
                                __blk_run_queue(sdev2->request_queue);
                                break;
                        }

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index b5a2f676c4f8fb61aa78a89e6dbfefd8e4a5748b..ee3f66a5e60ca40f24c3b4fe5a8e181bdd744168 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -260,7 +260,6 @@ struct request_queue
 
 #define blk_queue_plugged(q)   !list_empty(&(q)->plug_list)
 #define blk_queue_tagged(q)    test_bit(QUEUE_FLAG_QUEUED, &(q)->queue_flags)
-#define blk_queue_empty(q)     elv_queue_empty(q)
 #define blk_fs_request(rq)     ((rq)->flags & REQ_CMD)
 #define blk_pc_request(rq)     ((rq)->flags & REQ_BLOCK_PC)
 #define list_entry_rq(ptr)     list_entry((ptr), struct request, queuelist)