lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

paride: dequeue in-flight request

Browse Source 
pd/pf/pcd have track in-flight request by pd/pf/pcd_req.  They can be
converted to dequeueing model by updating fetching and completion
paths.  Convert them.

Note that removal of elv_next_request() call from pf_next_buf()
doesn't make any functional difference.  The path is traveled only
during partial completion of a request and elv_next_request() call
must return the same request anyway.

[ Impact: dequeue in-flight request ]

Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Tim Waugh <tim@cyberelk.net>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Tejun Heo
2009-05-08 11:54:06 +09:00
committed by Jens Axboe
parent 2d75ce084e
commit b12d4f82c1
3 changed files with 28 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
drivers/block/paride/pcd.c
View File

@@ -719,9 +719,12 @@ static void do_pcd_request(struct request_queue * q)
if (pcd_busy) if (pcd_busy)
return; return;
while (1) { while (1) {
if (!pcd_req) {
pcd_req = elv_next_request(q); pcd_req = elv_next_request(q);
if (!pcd_req) if (!pcd_req)
return; return;
blkdev_dequeue_request(pcd_req);
}
if (rq_data_dir(pcd_req) == READ) { if (rq_data_dir(pcd_req) == READ) {
struct pcd_unit *cd = pcd_req->rq_disk->private_data; struct pcd_unit *cd = pcd_req->rq_disk->private_data;
@@ -734,8 +737,10 @@ static void do_pcd_request(struct request_queue * q)
pcd_busy = 1; pcd_busy = 1;
ps_set_intr(do_pcd_read, NULL, 0, nice); ps_set_intr(do_pcd_read, NULL, 0, nice);
return; return;
} else } else {
__blk_end_request_cur(pcd_req, -EIO); __blk_end_request_all(pcd_req, -EIO);
pcd_req = NULL;
}
} }
} }
@@ -744,7 +749,8 @@ static inline void next_request(int err)
unsigned long saved_flags; unsigned long saved_flags;
spin_lock_irqsave(&pcd_lock, saved_flags); spin_lock_irqsave(&pcd_lock, saved_flags);
__blk_end_request_cur(pcd_req, err); if (!__blk_end_request_cur(pcd_req, err))
pcd_req = NULL;
pcd_busy = 0; pcd_busy = 0;
do_pcd_request(pcd_queue); do_pcd_request(pcd_queue);
spin_unlock_irqrestore(&pcd_lock, saved_flags); spin_unlock_irqrestore(&pcd_lock, saved_flags);

8
drivers/block/paride/pd.c
View File

@@ -410,11 +410,14 @@ static void run_fsm(void)
pd_claimed = 0; pd_claimed = 0;
phase = NULL; phase = NULL;
spin_lock_irqsave(&pd_lock, saved_flags); spin_lock_irqsave(&pd_lock, saved_flags);
__blk_end_request_cur(pd_req, if (!__blk_end_request_cur(pd_req,
res == Ok ? 0 : -EIO); res == Ok ? 0 : -EIO)) {
pd_req = elv_next_request(pd_queue); pd_req = elv_next_request(pd_queue);
if (!pd_req) if (!pd_req)
stop = 1; stop = 1;
else
blkdev_dequeue_request(pd_req);
}
spin_unlock_irqrestore(&pd_lock, saved_flags); spin_unlock_irqrestore(&pd_lock, saved_flags);
if (stop) if (stop)
return; return;
@@ -706,6 +709,7 @@ static void do_pd_request(struct request_queue * q)
pd_req = elv_next_request(q); pd_req = elv_next_request(q);
if (!pd_req) if (!pd_req)
return; return;
blkdev_dequeue_request(pd_req);
schedule_fsm(); schedule_fsm();
} }

8
drivers/block/paride/pf.c
View File

@@ -752,10 +752,8 @@ static struct request_queue *pf_queue;
static void pf_end_request(int err) static void pf_end_request(int err)
{ {
if (pf_req) { if (pf_req && !__blk_end_request_cur(pf_req, err))
__blk_end_request_cur(pf_req, err);
pf_req = NULL; pf_req = NULL;
}
} }
static void do_pf_request(struct request_queue * q) static void do_pf_request(struct request_queue * q)
@@ -763,9 +761,12 @@ static void do_pf_request(struct request_queue * q)
if (pf_busy) if (pf_busy)
return; return;
repeat: repeat:
if (!pf_req) {
pf_req = elv_next_request(q); pf_req = elv_next_request(q);
if (!pf_req) if (!pf_req)
return; return;
blkdev_dequeue_request(pf_req);
}
pf_current = pf_req->rq_disk->private_data; pf_current = pf_req->rq_disk->private_data;
pf_block = blk_rq_pos(pf_req); pf_block = blk_rq_pos(pf_req);
@@ -806,7 +807,6 @@ static int pf_next_buf(void)
if (!pf_count) { if (!pf_count) {
spin_lock_irqsave(&pf_spin_lock, saved_flags); spin_lock_irqsave(&pf_spin_lock, saved_flags);
pf_end_request(0); pf_end_request(0);
pf_req = elv_next_request(pf_queue);
spin_unlock_irqrestore(&pf_spin_lock, saved_flags); spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
if (!pf_req) if (!pf_req)
return 1; return 1;