forked from Minki/linux
mmc: block: Introduce queue semantics
Change from viewing the requests in progress as 'current' and 'previous', to viewing them as a queue. The current request is allocated to the first free slot. The presence of incomplete requests is determined from the count (mq->qcnt) of entries in the queue. Non-read-write requests (i.e. discards and flushes) are not added to the queue at all and require no special handling. Also no special handling is needed for the MMC_BLK_NEW_REQUEST case. As well as allowing an arbitrarily sized queue, the queue thread function is significantly simpler. Signed-off-by: Adrian Hunter <adrian.hunter@intel.com> Reviewed-by: Linus Walleij <linus.walleij@linaro.org> Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
This commit is contained in:
Adrian Hunter
Ulf Hansson
parent
8ddfe07e18
commit
cdf8a6fb48
@ -129,6 +129,13 @@ static inline int mmc_blk_part_switch(struct mmc_card *card,
|
||||
struct mmc_blk_data *md);
|
||||
static int get_card_status(struct mmc_card *card, u32 *status, int retries);
|
||||
|
||||
static void mmc_blk_requeue(struct request_queue *q, struct request *req)
|
||||
{
|
||||
spin_lock_irq(q->queue_lock);
|
||||
blk_requeue_request(q, req);
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
}
|
||||
|
||||
static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk)
|
||||
{
|
||||
struct mmc_blk_data *md;
|
||||
@ -1585,11 +1592,14 @@ static bool mmc_blk_rw_cmd_err(struct mmc_blk_data *md, struct mmc_card *card,
|
||||
return req_pending;
|
||||
}
|
||||
|
||||
static void mmc_blk_rw_cmd_abort(struct mmc_card *card, struct request *req)
|
||||
static void mmc_blk_rw_cmd_abort(struct mmc_queue *mq, struct mmc_card *card,
|
||||
struct request *req,
|
||||
struct mmc_queue_req *mqrq)
|
||||
{
|
||||
if (mmc_card_removed(card))
|
||||
req->rq_flags |= RQF_QUIET;
|
||||
while (blk_end_request(req, -EIO, blk_rq_cur_bytes(req)));
|
||||
mmc_queue_req_free(mq, mqrq);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1609,6 +1619,7 @@ static void mmc_blk_rw_try_restart(struct mmc_queue *mq, struct request *req,
|
||||
if (mmc_card_removed(mq->card)) {
|
||||
req->rq_flags |= RQF_QUIET;
|
||||
blk_end_request_all(req, -EIO);
|
||||
mmc_queue_req_free(mq, mqrq);
|
||||
return;
|
||||
}
|
||||
/* Else proceed and try to restart the current async request */
|
||||
@ -1623,14 +1634,23 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
struct mmc_blk_request *brq;
|
||||
int disable_multi = 0, retry = 0, type, retune_retry_done = 0;
|
||||
enum mmc_blk_status status;
|
||||
struct mmc_queue_req *mqrq_cur = mq->mqrq_cur;
|
||||
struct mmc_queue_req *mqrq_cur = NULL;
|
||||
struct mmc_queue_req *mq_rq;
|
||||
struct request *old_req;
|
||||
struct mmc_async_req *new_areq;
|
||||
struct mmc_async_req *old_areq;
|
||||
bool req_pending = true;
|
||||
|
||||
if (!new_req && !mq->mqrq_prev->req)
|
||||
if (new_req) {
|
||||
mqrq_cur = mmc_queue_req_find(mq, new_req);
|
||||
if (!mqrq_cur) {
|
||||
WARN_ON(1);
|
||||
mmc_blk_requeue(mq->queue, new_req);
|
||||
new_req = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (!mq->qcnt)
|
||||
return;
|
||||
|
||||
do {
|
||||
@ -1643,7 +1663,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
!IS_ALIGNED(blk_rq_sectors(new_req), 8)) {
|
||||
pr_err("%s: Transfer size is not 4KB sector size aligned\n",
|
||||
new_req->rq_disk->disk_name);
|
||||
mmc_blk_rw_cmd_abort(card, new_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1659,8 +1679,6 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
* and there is nothing more to do until it is
|
||||
* complete.
|
||||
*/
|
||||
if (status == MMC_BLK_NEW_REQUEST)
|
||||
mq->new_request = true;
|
||||
return;
|
||||
}
|
||||
|
||||
@ -1693,7 +1711,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
pr_err("%s BUG rq_tot %d d_xfer %d\n",
|
||||
__func__, blk_rq_bytes(old_req),
|
||||
brq->data.bytes_xfered);
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
@ -1701,11 +1719,14 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
req_pending = mmc_blk_rw_cmd_err(md, card, brq, old_req, req_pending);
|
||||
if (mmc_blk_reset(md, card->host, type)) {
|
||||
if (req_pending)
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
else
|
||||
mmc_queue_req_free(mq, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
if (!req_pending) {
|
||||
mmc_queue_req_free(mq, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
@ -1718,7 +1739,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
case MMC_BLK_ABORT:
|
||||
if (!mmc_blk_reset(md, card->host, type))
|
||||
break;
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
case MMC_BLK_DATA_ERR: {
|
||||
@ -1728,7 +1749,7 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
if (!err)
|
||||
break;
|
||||
if (err == -ENODEV) {
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
@ -1750,18 +1771,19 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
req_pending = blk_end_request(old_req, -EIO,
|
||||
brq->data.blksz);
|
||||
if (!req_pending) {
|
||||
mmc_queue_req_free(mq, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
break;
|
||||
case MMC_BLK_NOMEDIUM:
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
default:
|
||||
pr_err("%s: Unhandled return value (%d)",
|
||||
old_req->rq_disk->disk_name, status);
|
||||
mmc_blk_rw_cmd_abort(card, old_req);
|
||||
mmc_blk_rw_cmd_abort(mq, card, old_req, mq_rq);
|
||||
mmc_blk_rw_try_restart(mq, new_req, mqrq_cur);
|
||||
return;
|
||||
}
|
||||
@ -1778,6 +1800,8 @@ static void mmc_blk_issue_rw_rq(struct mmc_queue *mq, struct request *new_req)
|
||||
mq_rq->brq.retune_retry_done = retune_retry_done;
|
||||
}
|
||||
} while (req_pending);
|
||||
|
||||
mmc_queue_req_free(mq, mq_rq);
|
||||
}
|
||||
|
||||
void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
|
||||
@ -1785,9 +1809,8 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
|
||||
int ret;
|
||||
struct mmc_blk_data *md = mq->blkdata;
|
||||
struct mmc_card *card = md->queue.card;
|
||||
bool req_is_special = mmc_req_is_special(req);
|
||||
|
||||
if (req && !mq->mqrq_prev->req)
|
||||
if (req && !mq->qcnt)
|
||||
/* claim host only for the first request */
|
||||
mmc_get_card(card);
|
||||
|
||||
@ -1799,20 +1822,19 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
|
||||
goto out;
|
||||
}
|
||||
|
||||
mq->new_request = false;
|
||||
if (req && req_op(req) == REQ_OP_DISCARD) {
|
||||
/* complete ongoing async transfer before issuing discard */
|
||||
if (card->host->areq)
|
||||
if (mq->qcnt)
|
||||
mmc_blk_issue_rw_rq(mq, NULL);
|
||||
mmc_blk_issue_discard_rq(mq, req);
|
||||
} else if (req && req_op(req) == REQ_OP_SECURE_ERASE) {
|
||||
/* complete ongoing async transfer before issuing secure erase*/
|
||||
if (card->host->areq)
|
||||
if (mq->qcnt)
|
||||
mmc_blk_issue_rw_rq(mq, NULL);
|
||||
mmc_blk_issue_secdiscard_rq(mq, req);
|
||||
} else if (req && req_op(req) == REQ_OP_FLUSH) {
|
||||
/* complete ongoing async transfer before issuing flush */
|
||||
if (card->host->areq)
|
||||
if (mq->qcnt)
|
||||
mmc_blk_issue_rw_rq(mq, NULL);
|
||||
mmc_blk_issue_flush(mq, req);
|
||||
} else {
|
||||
@ -1821,13 +1843,7 @@ void mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
|
||||
}
|
||||
|
||||
out:
|
||||
if ((!req && !mq->new_request) || req_is_special)
|
||||
/*
|
||||
* Release host when there are no more requests
|
||||
* and after special request(discard, flush) is done.
|
||||
* In case sepecial request, there is no reentry to
|
||||
* the 'mmc_blk_issue_rq' with 'mqrq_prev->req'.
|
||||
*/
|
||||
if (!mq->qcnt)
|
||||
mmc_put_card(card);
|
||||
}
|
||||
|
||||
|
||||
@ -40,6 +40,35 @@ static int mmc_prep_request(struct request_queue *q, struct request *req)
|
||||
return BLKPREP_OK;
|
||||
}
|
||||
|
||||
struct mmc_queue_req *mmc_queue_req_find(struct mmc_queue *mq,
|
||||
struct request *req)
|
||||
{
|
||||
struct mmc_queue_req *mqrq;
|
||||
int i = ffz(mq->qslots);
|
||||
|
||||
if (i >= mq->qdepth)
|
||||
return NULL;
|
||||
|
||||
mqrq = &mq->mqrq[i];
|
||||
WARN_ON(mqrq->req || mq->qcnt >= mq->qdepth ||
|
||||
test_bit(mqrq->task_id, &mq->qslots));
|
||||
mqrq->req = req;
|
||||
mq->qcnt += 1;
|
||||
__set_bit(mqrq->task_id, &mq->qslots);
|
||||
|
||||
return mqrq;
|
||||
}
|
||||
|
||||
void mmc_queue_req_free(struct mmc_queue *mq,
|
||||
struct mmc_queue_req *mqrq)
|
||||
{
|
||||
WARN_ON(!mqrq->req || mq->qcnt < 1 ||
|
||||
!test_bit(mqrq->task_id, &mq->qslots));
|
||||
mqrq->req = NULL;
|
||||
mq->qcnt -= 1;
|
||||
__clear_bit(mqrq->task_id, &mq->qslots);
|
||||
}
|
||||
|
||||
static int mmc_queue_thread(void *d)
|
||||
{
|
||||
struct mmc_queue *mq = d;
|
||||
@ -50,7 +79,7 @@ static int mmc_queue_thread(void *d)
|
||||
|
||||
down(&mq->thread_sem);
|
||||
do {
|
||||
struct request *req = NULL;
|
||||
struct request *req;
|
||||
|
||||
spin_lock_irq(q->queue_lock);
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
@ -63,38 +92,17 @@ static int mmc_queue_thread(void *d)
|
||||
* Dispatch queue is empty so set flags for
|
||||
* mmc_request_fn() to wake us up.
|
||||
*/
|
||||
if (mq->mqrq_prev->req)
|
||||
if (mq->qcnt)
|
||||
cntx->is_waiting_last_req = true;
|
||||
else
|
||||
mq->asleep = true;
|
||||
}
|
||||
mq->mqrq_cur->req = req;
|
||||
spin_unlock_irq(q->queue_lock);
|
||||
|
||||
if (req || mq->mqrq_prev->req) {
|
||||
bool req_is_special = mmc_req_is_special(req);
|
||||
|
||||
if (req || mq->qcnt) {
|
||||
set_current_state(TASK_RUNNING);
|
||||
mmc_blk_issue_rq(mq, req);
|
||||
cond_resched();
|
||||
if (mq->new_request) {
|
||||
mq->new_request = false;
|
||||
continue; /* fetch again */
|
||||
}
|
||||
|
||||
/*
|
||||
* Current request becomes previous request
|
||||
* and vice versa.
|
||||
* In case of special requests, current request
|
||||
* has been finished. Do not assign it to previous
|
||||
* request.
|
||||
*/
|
||||
if (req_is_special)
|
||||
mq->mqrq_cur->req = NULL;
|
||||
|
||||
mq->mqrq_prev->brq.mrq.data = NULL;
|
||||
mq->mqrq_prev->req = NULL;
|
||||
swap(mq->mqrq_prev, mq->mqrq_cur);
|
||||
} else {
|
||||
if (kthread_should_stop()) {
|
||||
set_current_state(TASK_RUNNING);
|
||||
@ -177,6 +185,20 @@ static void mmc_queue_setup_discard(struct request_queue *q,
|
||||
queue_flag_set_unlocked(QUEUE_FLAG_SECERASE, q);
|
||||
}
|
||||
|
||||
static struct mmc_queue_req *mmc_queue_alloc_mqrqs(int qdepth)
|
||||
{
|
||||
struct mmc_queue_req *mqrq;
|
||||
int i;
|
||||
|
||||
mqrq = kcalloc(qdepth, sizeof(*mqrq), GFP_KERNEL);
|
||||
if (mqrq) {
|
||||
for (i = 0; i < qdepth; i++)
|
||||
mqrq[i].task_id = i;
|
||||
}
|
||||
|
||||
return mqrq;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MMC_BLOCK_BOUNCE
|
||||
static bool mmc_queue_alloc_bounce_bufs(struct mmc_queue *mq,
|
||||
unsigned int bouncesz)
|
||||
@ -279,12 +301,9 @@ int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card,
|
||||
return -ENOMEM;
|
||||
|
||||
mq->qdepth = 2;
|
||||
mq->mqrq = kcalloc(mq->qdepth, sizeof(struct mmc_queue_req),
|
||||
GFP_KERNEL);
|
||||
mq->mqrq = mmc_queue_alloc_mqrqs(mq->qdepth);
|
||||
if (!mq->mqrq)
|
||||
goto blk_cleanup;
|
||||
mq->mqrq_cur = &mq->mqrq[0];
|
||||
mq->mqrq_prev = &mq->mqrq[1];
|
||||
mq->queue->queuedata = mq;
|
||||
|
||||
blk_queue_prep_rq(mq->queue, mmc_prep_request);
|
||||
|
||||
@ -34,21 +34,21 @@ struct mmc_queue_req {
|
||||
struct scatterlist *bounce_sg;
|
||||
unsigned int bounce_sg_len;
|
||||
struct mmc_async_req areq;
|
||||
int task_id;
|
||||
};
|
||||
|
||||
struct mmc_queue {
|
||||
struct mmc_card *card;
|
||||
struct task_struct *thread;
|
||||
struct semaphore thread_sem;
|
||||
bool new_request;
|
||||
bool suspended;
|
||||
bool asleep;
|
||||
struct mmc_blk_data *blkdata;
|
||||
struct request_queue *queue;
|
||||
struct mmc_queue_req *mqrq;
|
||||
struct mmc_queue_req *mqrq_cur;
|
||||
struct mmc_queue_req *mqrq_prev;
|
||||
int qdepth;
|
||||
int qcnt;
|
||||
unsigned long qslots;
|
||||
};
|
||||
|
||||
extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *,
|
||||
@ -64,4 +64,8 @@ extern void mmc_queue_bounce_post(struct mmc_queue_req *);
|
||||
|
||||
extern int mmc_access_rpmb(struct mmc_queue *);
|
||||
|
||||
extern struct mmc_queue_req *mmc_queue_req_find(struct mmc_queue *,
|
||||
struct request *);
|
||||
extern void mmc_queue_req_free(struct mmc_queue *, struct mmc_queue_req *);
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue
Block a user