Skip to contentSkip to conversation

blk-mq: put driver tag when this request is completed

PATCH Applied Ming Lei 4 participants 14 messages Jun 29, 2020 – Jul 2, 2020

Subsystems (3)
lore
Share & tools
lore

Ming Lei

author
#0 lore raw

PATCH 1/1 blk-mq: put driver tag when this request is completed

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>
---
 block/blk-flush.c | 6 ------
 block/blk-mq.c    | 2 ++
 2 files changed, 2 insertions(+), 6 deletions(-)
block/blk-flush.c +0 -6
index 15ae0155ec07..21108a550fbf 100644
@@ -240,7 +240,6 @@ static void flush_end_io(struct request *flush_rq, blk_status_t error)
 		blk_mq_tag_set_rq(hctx, flush_rq->tag, fq->orig_rq);
 		flush_rq->tag = -1;
 	} else {
-		blk_mq_put_driver_tag(flush_rq);
 		flush_rq->internal_tag = -1;
 	}
 
@@ -341,11 +340,6 @@ static void mq_flush_data_end_io(struct request *rq, blk_status_t error)
 	unsigned long flags;
 	struct blk_flush_queue *fq = blk_get_flush_queue(q, ctx);
 
-	if (q->elevator) {
-		WARN_ON(rq->tag < 0);
-		blk_mq_put_driver_tag(rq);
-	}
-
 	/*
 	 * After populating an empty queue, kick it to avoid stall.  Read
 	 * the comment in flush_end_io().
block/blk-mq.c +2 -0
index b8738b3c6d06..d07e55455726 100644
@@ -674,6 +674,8 @@ bool blk_mq_complete_request_remote(struct request *rq)
 {
 	WRITE_ONCE(rq->state, MQ_RQ_COMPLETE);
 
+	blk_mq_put_driver_tag(rq);
+
 	/*
 	 * For a polled request, always complete locallly, it's pointless
 	 * to redirect the completion.
Signature · 1 line
2.25.2
Reviewed-by on v1 1/1
#1 lore raw
Quoted 7 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

A bunch of comments on the surrounding code from reviewing it, though:

- blk_mq_put_driver_tag and __blk_mq_put_driver_tag can and should be moved to blk-mq.c and marked static in a follow on patch (and possibly merged as well)
- The rq->internal_tag == BLK_MQ_NO_TAG check in shold probably be replaced with a !data->q->elevator check to make it more obvious that we are only putting the driver tag for the iosched case

maintainer Applied
#2 lore raw
In reply to Ming Lei
Quoted 7 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Applied, thanks.

Signature · 1 line
Jens Axboe
#3 lore raw
In reply to Ming Lei

Hi

Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland
author
#4 lore raw

Hi Marek,

Quoted 14 lines · Marek Szyprowski

Hi

Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>
Quoted 7 lines

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

What is the exact eMMC's driver code(include the host driver)?

The usual way for handling completion is that host driver notifies block layer via blk_mq_complete_request() after the LLD specific handling for this request is done.

However, there might be driver which may use rq->tag in its rq completion handler. I will see if the special case can be dealt with once you share the driver info.

Thanks,
Ming

#5 lore raw

Hi Ming,

Quoted 12 lines · Ming Lei
Quoted 11 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>
Quoted 8 lines
Quoted 7 lines

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Quoted 7 lines

The usual way for handling completion is that host driver notifies block layer via blk_mq_complete_request() after the LLD specific handling for this request is done.

However, there might be driver which may use rq->tag in its rq completion handler. I will see if the special case can be dealt with once you share the driver info.

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland
#6 lore raw

Hi,

Quoted 21 lines · Marek Szyprowski
Quoted 20 lines · Ming Lei
Quoted 19 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap
I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 12 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Quoted 8 lines

The usual way for handling completion is that host driver notifies block layer via blk_mq_complete_request() after the LLD specific handling for this request is done.

However, there might be driver which may use rq->tag in its rq completion
handler. I will see if the special case can be dealt with once you share the driver info.

One more information: revering 37f4a24c2469a10a4c16c641671bd766e276cf9f, 723bf178f158abd1ce6069cb049581b3cb003aab and 36a3df5a4574d5ddf59804fcd0c4e9654c514d9a on top of today's linux-next fixes the issues on the tested system, what shows that the bisect is indeed correct and there is no other hidden issue.

The most surprising thing to me is that other Exynos5422-based boards I have, which also use same eMMC controller, work fine...

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland
author
#7 lore raw
In reply to Marek Szyprowski
Quoted 22 lines · Marek Szyprowski

Hi Ming,

Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 3 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

        spin_lock_irqsave(&cq_host->lock, flags);
        timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
 		goto out_unlock;
 	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
 	cq_host->slot[tag].mrq = mrq;
 	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +1 -0
index a5e05ed0fda3..11a4c1f3a970 100644
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
 		return -EBUSY;
 	}
 
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
 	hsq->slot[tag].mrq = mrq;
 
 	/*

Thanks,
Ming

maintainer
#8 lore raw
Quoted 23 lines · Ming Lei
Quoted 22 lines · Marek Szyprowski

Hi Ming,

Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

Just a heads up that I've queued up a revert of the offending commits. It's not just this issue, there's also another one reported with swapping.

Signature · 1 line
Jens Axboe
#9 lore raw
In reply to Ming Lei

Hi Ming,

Quoted 72 lines · Ming Lei
Quoted 20 lines · Marek Szyprowski
Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 2 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

         spin_lock_irqsave(&cq_host->lock, flags);
         timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
  		goto out_unlock;
  	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
  	cq_host->slot[tag].mrq = mrq;
  	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +0 -0
index a5e05ed0fda3..11a4c1f3a970 100644

drivers/mmc/host/mmc_hsq.c static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq) · line 233

Quoted 7 lines
drivers/mmc/host/mmc_hsq.c +1 -0
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
  		return -EBUSY;
  	}
 
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
  	hsq->slot[tag].mrq = mrq;
 
  	/*

None of the above is even compiled for my system (I'm using arm/exynos_defconfig), so this must be something else.

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland
author
#10 lore raw
Quoted 78 lines · Marek Szyprowski

Hi Ming,

Quoted 75 lines · Ming Lei
Quoted 20 lines · Marek Szyprowski
Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 2 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

         spin_lock_irqsave(&cq_host->lock, flags);
         timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
  		goto out_unlock;
  	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
  	cq_host->slot[tag].mrq = mrq;
  	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +0 -0
index a5e05ed0fda3..11a4c1f3a970 100644
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
  		return -EBUSY;
  	}
 
Quoted 7 lines

drivers/mmc/host/mmc_hsq.c static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq) · line 233

Quoted 4 lines
drivers/mmc/host/mmc_hsq.c +1 -0
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
  	hsq->slot[tag].mrq = mrq;
 
  	/*

None of the above is even compiled for my system (I'm using arm/exynos_defconfig), so this must be something else.

Hello Marek,

Or can you boot the system with one workable disk(usb, nand, ...)? then run some IO test on this eMMC, and collect debugfs log via the following command after the hang is triggered:

(cd /sys/kernel/debug/block/$MMC && find . -type f -exec grep -aH . {} \;)

$MMC is this mmc disk name.

Thanks,
Ming

#11 lore raw
Quoted 85 lines · Ming Lei
Quoted 76 lines · Marek Szyprowski
Quoted 75 lines · Ming Lei
Quoted 20 lines · Marek Szyprowski
Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 2 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

          spin_lock_irqsave(&cq_host->lock, flags);
          timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
   		goto out_unlock;
   	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
   	cq_host->slot[tag].mrq = mrq;
   	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +0 -0
index a5e05ed0fda3..11a4c1f3a970 100644
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
   		return -EBUSY;
   	}
 
Quoted 6 lines

drivers/mmc/host/mmc_hsq.c static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq) · line 233

Quoted 4 lines
drivers/mmc/host/mmc_hsq.c +1 -0
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
   	hsq->slot[tag].mrq = mrq;
 
   	/*

None of the above is even compiled for my system (I'm using arm/exynos_defconfig), so this must be something else.

Hello Marek,

Quoted 7 lines

Or can you boot the system with one workable disk(usb, nand, ...)? then run some IO test on this eMMC, and collect debugfs log via the following command after the hang is triggered:

(cd /sys/kernel/debug/block/$MMC && find . -type f -exec grep -aH . {} \;)

$MMC is this mmc disk name.

I have no physical access to this system now, but I managed to run a screen session just after the boot to have more than one shell. Here is the dump when the other shell locks:

# (cd /sys/kernel/debug/block/mmcblk0 && find . -type f -exec grep -aH . {} \;)
./hctx0/cpu7/completed:372 0
./hctx0/cpu7/merged:0
./hctx0/cpu7/dispatched:372 0
./hctx0/cpu6/completed:385 0
./hctx0/cpu6/merged:0
./hctx0/cpu6/dispatched:385 0
./hctx0/cpu5/completed:525 0
./hctx0/cpu5/merged:0
./hctx0/cpu5/dispatched:526 0
./hctx0/cpu4/completed:707 0
./hctx0/cpu4/merged:0
./hctx0/cpu4/dispatched:708 0
./hctx0/cpu3/completed:97 1
./hctx0/cpu3/merged:0
./hctx0/cpu3/dispatched:97 2
./hctx0/cpu2/completed:180 0
./hctx0/cpu2/merged:0
./hctx0/cpu2/dispatched:181 0
./hctx0/cpu1/completed:257 0
./hctx0/cpu1/merged:0
./hctx0/cpu1/dispatched:257 2
./hctx0/cpu0/completed:45 0
./hctx0/cpu0/merged:0
./hctx0/cpu0/dispatched:45 0
./hctx0/type:default
./hctx0/dispatch_busy:0
./hctx0/active:0
./hctx0/run:2126
./hctx0/queued:2575
./hctx0/dispatched:       0     6
./hctx0/dispatched:       1     2050
./hctx0/dispatched:       2     150
./hctx0/dispatched:       4     11
./hctx0/dispatched:       8     1
./hctx0/dispatched:      16     1
./hctx0/dispatched:      32+    1
./hctx0/io_poll:considered=0
./hctx0/io_poll:invoked=0
./hctx0/io_poll:success=0
./hctx0/sched_tags_bitmap:00000000: 0020 0000 1000 0000 0000 7000 0800 0000 ./hctx0/sched_tags:nr_tags=128 ./hctx0/sched_tags:nr_reserved_tags=0 ./hctx0/sched_tags:active_queues=0 ./hctx0/sched_tags:bitmap_tags:
./hctx0/sched_tags:depth=128
./hctx0/sched_tags:busy=6
./hctx0/sched_tags:cleared=40
./hctx0/sched_tags:bits_per_word=32
./hctx0/sched_tags:map_nr=4
./hctx0/sched_tags:alloc_hint={126, 78, 98, 35, 12, 83, 11, 21} ./hctx0/sched_tags:wake_batch=8
./hctx0/sched_tags:wake_index=0
./hctx0/sched_tags:ws_active=0
./hctx0/sched_tags:ws={
./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:     {.wait_cnt=8, .wait=inactive}, ./hctx0/sched_tags:}
./hctx0/sched_tags:round_robin=0 ./hctx0/sched_tags:min_shallow_depth=4294967295 ./hctx0/tags_bitmap:00000000: ffff ffff ffff ffff ./hctx0/tags:nr_tags=64
./hctx0/tags:nr_reserved_tags=0
./hctx0/tags:active_queues=0
./hctx0/tags:bitmap_tags:
./hctx0/tags:depth=64
./hctx0/tags:busy=64
./hctx0/tags:cleared=0
./hctx0/tags:bits_per_word=16
./hctx0/tags:map_nr=4
./hctx0/tags:alloc_hint={14, 0, 0, 0, 0, 0, 13, 22} ./hctx0/tags:wake_batch=8
./hctx0/tags:wake_index=0
./hctx0/tags:ws_active=0
./hctx0/tags:ws={
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:   {.wait_cnt=8, .wait=inactive},
./hctx0/tags:}
./hctx0/tags:round_robin=0 ./hctx0/tags:min_shallow_depth=4294967295 ./hctx0/ctx_map:00000000: 00
./hctx0/dispatch:35e4bf48 {.op=FLUSH, .cmd_flags=PREFLUSH, .rq_flags=FLUSH_SEQ, .state=idle, .tag=-1, .internal_tag=84} ./hctx0/flags:alloc_policy=FIFO SHOULD_MERGE|BLOCKING ./hctx0/state:SCHED_RESTART
./sched/starved:0
./sched/batching:1
./sched/write_fifo_list:ab51b2cc {.op=WRITE, .cmd_flags=META|PRIO|BACKGROUND, .rq_flags=ELVPRIV|IO_STAT|HASHED, .state=idle, .tag=-1, .internal_tag=85} ./sched/write_fifo_list:ac854e48 {.op=WRITE, .cmd_flags=META|PRIO|BACKGROUND, .rq_flags=ELVPRIV|IO_STAT|HASHED, .state=idle, .tag=-1, .internal_tag=86} ./sched/write_fifo_list:b12e714a {.op=WRITE, .cmd_flags=, .rq_flags=ELVPRIV|IO_STAT|HASHED, .state=idle, .tag=-1, .internal_tag=36} ./sched/write_fifo_list:99383a87 {.op=WRITE, .cmd_flags=SYNC, .rq_flags=ELVPRIV|IO_STAT|HASHED, .state=idle, .tag=-1, .internal_tag=99} ./sched/read_fifo_list:29365a9b {.op=READ, .cmd_flags=FAILFAST_DEV|FAILFAST_TRAag=-1, .internal_tag=13}AHEAD, .rq_flags=ELVPRIV|IO_STAT|HASHED, .state=idle, .ta ./write_hints:hint0: 0
./write_hints:hint1: 0
./write_hints:hint2: 0
./write_hints:hint3: 0
./write_hints:hint4: 0 ./state:SAME_COMP|NONROT|IO_STAT|DISCARD|SECERASE|INIT_DONE|WC|FUA|REGISTERED ./pm_only:0
./poll_stat:read  (512 Bytes): samples=0
./poll_stat:write (512 Bytes): samples=0
./poll_stat:read  (1024 Bytes): samples=0
./poll_stat:write (1024 Bytes): samples=0
./poll_stat:read  (2048 Bytes): samples=0
./poll_stat:write (2048 Bytes): samples=0
./poll_stat:read  (4096 Bytes): samples=0
./poll_stat:write (4096 Bytes): samples=0
./poll_stat:read  (8192 Bytes): samples=0
./poll_stat:write (8192 Bytes): samples=0
./poll_stat:read  (16384 Bytes): samples=0
./poll_stat:write (16384 Bytes): samples=0
./poll_stat:read  (32768 Bytes): samples=0
./poll_stat:write (32768 Bytes): samples=0
./poll_stat:read  (65536 Bytes): samples=0
./poll_stat:write (65536 Bytes): samples=0
root@target:~#

I hope it helps.

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland
author
#12 lore raw
Quoted 90 lines · Marek Szyprowski
Quoted 89 lines · Ming Lei
Quoted 76 lines · Marek Szyprowski
Quoted 75 lines · Ming Lei
Quoted 20 lines · Marek Szyprowski
Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 2 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

          spin_lock_irqsave(&cq_host->lock, flags);
          timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
   		goto out_unlock;
   	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
   	cq_host->slot[tag].mrq = mrq;
   	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +0 -0
index a5e05ed0fda3..11a4c1f3a970 100644
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
   		return -EBUSY;
   	}
 
Quoted 6 lines

drivers/mmc/host/mmc_hsq.c static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq) · line 233

Quoted 4 lines
drivers/mmc/host/mmc_hsq.c +1 -0
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
   	hsq->slot[tag].mrq = mrq;
 
   	/*

None of the above is even compiled for my system (I'm using arm/exynos_defconfig), so this must be something else.

Hello Marek,

Or can you boot the system with one workable disk(usb, nand, ...)? then run some IO test on this eMMC, and collect debugfs log via the following command after the hang is triggered:

Quoted 6 lines
Quoted 3 lines

(cd /sys/kernel/debug/block/$MMC && find . -type f -exec grep -aH . {} \;)

$MMC is this mmc disk name.

I hope it helps.

It does help, :-)

Thanks for collecting the log, now I understood the reason: flush request's driver tag is leaked in case that request isn't done via blk_mq_complete_request(), such as freed via blk_mq_end_request() directly.

Please try the following patch, which should have been one two-line change if the driver tag cleanup patch isn't merged.

block/blk-mq.c +24 -22
index ebab8f1044cb..7d62e9e5972e 100644
@@ -532,6 +532,26 @@ void blk_mq_free_request(struct request *rq)
 }
 EXPORT_SYMBOL_GPL(blk_mq_free_request);
 
+static void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx,
+		struct request *rq)
+{
+	blk_mq_put_tag(hctx->tags, rq->mq_ctx, rq->tag);
+	rq->tag = BLK_MQ_NO_TAG;
+
+	if (rq->rq_flags & RQF_MQ_INFLIGHT) {
+		rq->rq_flags &= ~RQF_MQ_INFLIGHT;
+		atomic_dec(&hctx->nr_active);
+	}
+}
+
+static inline void blk_mq_put_driver_tag(struct request *rq)
+{
+	if (rq->tag == BLK_MQ_NO_TAG || rq->internal_tag == BLK_MQ_NO_TAG)
+		return;
+
+	__blk_mq_put_driver_tag(rq->mq_hctx, rq);
+}
+
 inline void __blk_mq_end_request(struct request *rq, blk_status_t error)
 {
 	u64 now = 0;
@@ -551,6 +571,7 @@ inline void __blk_mq_end_request(struct request *rq, blk_status_t error)
 
 	if (rq->end_io) {
 		rq_qos_done(rq->q, rq);
+		blk_mq_put_driver_tag(rq);
 		rq->end_io(rq, error);
 	} else {
 		blk_mq_free_request(rq);
@@ -862,26 +883,6 @@ static inline bool blk_mq_complete_need_ipi(struct request *rq)
 	return cpu_online(rq->mq_ctx->cpu);
 }
 
-static void __blk_mq_put_driver_tag(struct blk_mq_hw_ctx *hctx,
-		struct request *rq)
-{
-	blk_mq_put_tag(hctx->tags, rq->mq_ctx, rq->tag);
-	rq->tag = BLK_MQ_NO_TAG;
-
-	if (rq->rq_flags & RQF_MQ_INFLIGHT) {
-		rq->rq_flags &= ~RQF_MQ_INFLIGHT;
-		atomic_dec(&hctx->nr_active);
-	}
-}
-
-static inline void blk_mq_put_driver_tag(struct request *rq)
-{
-	if (rq->tag == BLK_MQ_NO_TAG || rq->internal_tag == BLK_MQ_NO_TAG)
-		return;
-
-	__blk_mq_put_driver_tag(rq->mq_hctx, rq);
-}
-
 bool blk_mq_complete_request_remote(struct request *rq)
 {
 	WRITE_ONCE(rq->state, MQ_RQ_COMPLETE);
@@ -1185,9 +1186,10 @@ static bool blk_mq_check_expired(struct blk_mq_hw_ctx *hctx,
 	if (blk_mq_req_expired(rq, next))
 		blk_mq_rq_timed_out(rq, reserved);
 
-	if (is_flush_rq(rq, hctx))
+	if (is_flush_rq(rq, hctx)) {
+		blk_mq_put_driver_tag(rq);
 		rq->end_io(rq, 0);
-	else if (refcount_dec_and_test(&rq->ref))
+	} else if (refcount_dec_and_test(&rq->ref))
 		__blk_mq_free_request(rq);
 
 	return true;

Thanks,
Ming

#13 lore raw

Hi Ming,

Quoted 98 lines · Ming Lei
Quoted 90 lines · Marek Szyprowski
Quoted 89 lines · Ming Lei
Quoted 76 lines · Marek Szyprowski
Quoted 75 lines · Ming Lei
Quoted 20 lines · Marek Szyprowski
Quoted 19 lines · Ming Lei
Quoted 18 lines · Marek Szyprowski
Quoted 10 lines · Ming Lei

It is natural to release driver tag when this request is completed by LLD or device since its purpose is for LLD use.

One big benefit is that the released tag can be re-used quicker since bio_endio() may take too long.

Meantime we don't need to release driver tag for flush request.

Cc Christoph Hellwig <[email protected]>

This patch landed recently in linux-next as commit 36a3df5a4574. Sadly it causes a regression on one of my test systems (ARM 32bit, Samsung Exynos5422 SoC based Odroid XU3 board with eMMC). The system boots fine and then after a few seconds every executed command hangs. No panic/ops/any other message. I will try to provide more information asap I find something to share. Simple reverting it in linux-next is not possible due to dependencies.

Quoted 2 lines
Quoted 1 line

What is the exact eMMC's driver code(include the host driver)?

dwmmc-exynos (drivers/mmc/host/dw_mmc-exynos.c)

Hi,

Just take a quick look at mmc code, there are only two req->tag consumers:

1) cqhci_tag
cqhci_tag

	cqhci_request
		host->cqe_ops->cqe_request
			mmc_cqe_start_req
	cqhci_timeout

2) mmc_hsq_request
mmc_hsq_request

	host->cqe_ops->cqe_request
		mmc_cqe_start_req

mmc_cqe_start_req() is called before issuing this request to hardware, so completion won't happen when the tag is used in mmc_cqe_start_req().

cqhci_timeout() may race with normal completion, however looks the following code can handle the race correctly:

           spin_lock_irqsave(&cq_host->lock, flags);
           timed_out = slot->mrq == mrq;

So still no idea why the commit causes the trouble for mmc.

Do you know it is cqhci or mmc_hsh which works for dw_mmc-exynos? And can you apply the following patch and see if warning can be triggered?

drivers/mmc/host/cqhci.c +1 -0
index 75934f3c117e..2cb49ecfbf34 100644
@@ -612,6 +612,7 @@ static int cqhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
    		goto out_unlock;
    	}
 
+	WARN_ON_ONCE(cq_host->slot[tag].mrq);
    	cq_host->slot[tag].mrq = mrq;
    	cq_host->slot[tag].flags = 0;
 
drivers/mmc/host/mmc_hsq.c +0 -0
index a5e05ed0fda3..11a4c1f3a970 100644
@@ -227,6 +227,7 @@ static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq)
    		return -EBUSY;
    	}
 
Quoted 6 lines

drivers/mmc/host/mmc_hsq.c static int mmc_hsq_request(struct mmc_host *mmc, struct mmc_request *mrq) · line 233

Quoted 4 lines
drivers/mmc/host/mmc_hsq.c +1 -0
+	WARN_ON_ONCE(hsq->slot[tag].mrq);
    	hsq->slot[tag].mrq = mrq;
 
    	/*

None of the above is even compiled for my system (I'm using arm/exynos_defconfig), so this must be something else.

Hello Marek,

Or can you boot the system with one workable disk(usb, nand, ...)? then run some IO test on this eMMC, and collect debugfs log via the following command after the hang is triggered:

Quoted 5 lines
Quoted 3 lines

(cd /sys/kernel/debug/block/$MMC && find . -type f -exec grep -aH . {} \;)

$MMC is this mmc disk name.

I hope it helps.

It does help, :-)

Quoted 7 lines

Thanks for collecting the log, now I understood the reason: flush request's driver tag is leaked in case that request isn't done via blk_mq_complete_request(), such as freed via blk_mq_end_request() directly.

Please try the following patch, which should have been one two-line change if the driver tag cleanup patch isn't merged.

Yes, this fixes the issue on my test system! :)

Feel free to add:

to the final patch.

Best regards

Signature · 2 lines
Marek Szyprowski, PhD
Samsung R&D Institute Poland